Re: Factory Pattern

[Georg Bauhaus <bauhaus.rm.tsoh@maps.futureapps.de>]

Dmitry A. Kazakov wrote:
> On Wed, 25 Jul 2007 11:19:31 -0700, shaunpatterson@gmail.com wrote:

>> function create (i : Integer) return MessageInteger is
>>      msg : MessageInteger;
>> begin
>>      msg.value := i;
>>      return msg;
> 
> You could use an extension aggregate here:
> 
>    return (Message with I);

Or even

     return (Message with value => I);


>> Factory method:
>>
>> -- I would like it to work like this...
>> function createMessage (type : Integer) return Message_Class is
> 
> "Type" is a reserved word.
> 
>> begin
>>          case type is
>>                  when 0 =>
>>                       return MessageInteger_Pkg.create (1234);
>>                  when others =>
>>                        return MessageSomethingElse_Pkg.create
>> ("blah");
>>          end case
>>
>> end createMessage
> 
>   function Factory (What : Integer) return Message'Class is

Let me just stress that 'Class is the important part of Factory 
because it adds the polymophism: T'Class stands for all types that
have T as a parent (including T). This roughly corresponds to the
pointer use in C++ but as Dmitry has already mentioned, the Ada
language takes care of polymorphic reference for you already for
'Class types. (And it isn't pointing that adds polymorphism, it
is 'Class.)
So you needn't return pointers to objects in the T hierarchy.
You can just return objects.

  The returned objects will either be passed to subprograms,
or assigned. 


   Some_Message_Op(Factory(Event));
     -- chosen based on what Factory returns (the return
     -- value's tag)


   declare
      What_is_It: Message'Class := Factory (Event);
   begin
      Some_Message_Op(What_is_It);
        -- chosen based on tag of What_Is_It
      ...
   end;


   declare
      What_is_It: MessageInteger := MessageInteger(Factory (Event));
       -- you could do this if you know that the Factory returns an 
       -- object that can act as one of type MessageInteger
   begin
      if What_is_It.value > 42 then
        ...
   end;


>    begin
>       case What is
>          when 0 => return MessageInteger_Pkg.Create (1234);
>          ...

Another feature that I would consider when writing a factory is
case coverage, like this:
 As your program is such that you know all *possible* types
before runtime, define an enumeration that has an identifier
for each of the possible types.  Then in the body of Facroty,
leave out "others" from the case statement. The compiler will
then check that all cases are covered which makes the factory
more predictable.

This works for user defined numeric types, too. For example,
if the What variable stands for expected average number
of births per woman in one socioeconometeriological region,
the Factory will create family types:

   type Kid_Count is range 0 .. 20;

   What := Births_per_Woman
      (Latitude => ..., GDP => ..., Wheather => ...);

   case What is

      when 0 =>
         return Couples.Create;

      when 1 =>
         if Longitude in China.West .. China.East then
            return China.Create(1);
         else
            return High_Tec.Create(Average => 1.27);
         end if;

      when 2 =>
         return Saturated.Create(1.73);

      when 3 | 4 => 
         return Sunnier.Create(Population => Mixed);

      when 5 =>
          return Silent_Africa.Create(...);

      when 6 .. 8 =>
         return Shaken_Africa.Create(...);

      when 9 .. 20 =>
          return Random.Create;
   end case;