Re: Factory Pattern

[Matthew Heaney <mheaney@on2.com>]

On Jul 25, 2:19 pm, shaunpatter...@gmail.com wrote:
>
> My code looks something like this:
>
> type Message is abstract tagged;

You need to say more here, but see below.


> type Message_Class is access all Message'Class;

In Ada05 you might not need this access type, since functions can now
return an anonymous access value.

Also, if you want to force clients of your abstraction to call your
constructor, you should probably declare the type as limited:

  type Message is abstract tagged limited null record;

If your root type has payload that you want to make private, then you
can say:

  type Message is abstract tagged limited private;
  ...
private
  type Message is abstract tagged limited record ... end record;


> derived type:
>
> package MessageInteger_Pkg is

You probably want to declare the partial view of your type in the
public part, and with an unknown discriminant:

  type MessageInteger (<>) is new Message with private;


>
> -- I want this to act like a constructor
> -- Just fills in the value
> function create (i : Integer) return MessageInteger;
>
> private
> type MessageInteger with new Message with
> record
>       value : Integer;
> end record;
>
> end MessageInteger_Pkg;
>
> -- create looks like this:
> function create (i : Integer) return MessageInteger is
>      msg : MessageInteger;
> begin
>      msg.value := i;
>      return msg;
> end create;

This won't work if the type is limited.  You can say either:

  function Create (I : Integer) return MessageInteger is
  begin
     return (Value => I);
  end;

or

  function Create (I : Integer) return MessageInteger is
  begin
     return Result : MessageInteger do
        Result.Value := I;
     end return;
  end Create;


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

You can do this:

  function CreateMessage (T : Integer) return Message'Class is
  begin
     case T is
        when 0 =>
           return MessageInteger_Pkg.Create (T);
        when others =>
           return MessageSomethingElse_Pkg.Create;
     end case;
   end CreateMessage;

This avoids any use of pointers.  This might or might not be what you
need.  Another possibility is:

  function CreateMessage (T : Integer) return not null access
Message'Class is
  begin
     case T is
        when 0 =>
           return MessageInteger_Pkg.Create (T);
        when others =>
           return MessageSomethingElse_Pkg.Create;
     end case;
   end CreateMessage;

(You'll have to also change the ctors for each derived type to return
an access value designating the specific type.)


> However - it doesn't like me returning the MessageInteger from a
> class
> that returns a Message_Class (obviously..)

Right, because (in your original example) MessageInteger_Pkg.Create
returns a value of the type, while CreateMessage returns an access
value.


> Now if I do this -- changing the constructor to take in a
> Message_Class....
>
> function createMessage (type : Integer) return Message_Class is
>       decodedMessage : Message_Class;
> begin
>          case type is
>                  when 0 =>
>                       decodedMessage := new
> MessageInteger_Pkg.MessageInteger;
>                        MessageInteger_Pkg.create (decodedMessage,
> 1234);        -- change the decoded message this way
>                        return decodedMessage;
>                  when others =>
>                        return MessageSomethingElse_Pkg.create
> ("blah");
>          end case
>
> end createMessage
>
> -- That method works... but I find the intermediary step of making a
> new object decodedMessage
> to someone unneeded?  There must be another way of doing this.
> Perhaps I should move the "new"
> to the create function?

Yes, move the new to the Create function for each derived type.
(There are others ways of solving this problem, but that will at least
get you going.)


> And... I'm not completely sure I'm doing all this correctly in Ada.
> LIke I said,  I'm very new to
> Ada.

That's OK.  That's what CLA is for.  Welcome!

-Matt