Re: ANNOUNCE: Abstract Factory posted to ACM patterns archive

[jerry@jvdsys.stuyts.nl (Jerry van Dijk)]

Matthew Heaney (matthew_heaney@acm.org) wrote:

: "Factory" just has its common meaning: an abstraction that you use to
: create other abstractions.  This is why it falls under the rubric of
: "creational patterns."  Different factories create different items.

As I recall from the GoF book, my impression (also stated somewhere,
I believe) was that one of the essentials was using construction instead
of inheritance as the main design principle. The implementation of the
idea seems to be decoupling through dispatching and access types. Looking
at your example, I see:

:   type Root_Hamburger_Type (<>) is abstract tagged limited private;
:   type Hamburger_Access is access all Root_Hamburger_Type'Class;
:   function New_Hamburger return Hamburger_Access;
:   function New_Hamburger return Hamburger_Access;
:   Hamburger : constant Hamburger_Access := Factory.New_Hamburger;

With other words, pointers seem to be the essential tool for using this
design method. Although the thinking behind the pattern idea is powerful by
its rigid application, whenever I try to apply it, I end up with programs
that seem to become impregnable through the heavy use of indirection, 
overloading and dispatching. Gone is the "clear and elegant" (for lack of
better wording) ADT based structure I like so much in Ada. 

Now, it could be that this is indeed true, but I rather suspect that I
made a wrong turn somewhere. Anyone who has been there, and solved this
problem ? 

--
-- Jerry van Dijk | Leiden, Holland
-- Team Ada       | jdijk@acm.org
-- see http://stad.dsl.nl/~jvandyk