// Purpose.  Factory Method             #include <iostream>
//           creation via inheritance   using namespace std;
//
// Discussion.  The architect has done  class Stooge {
// an admirable job of decoupling the   public:
// client from Stooge concrete derived     virtual void slapStick() = 0;
// classes, and, exercising polymor-    };
// phism.  But there remains coupling
// where instances are actually         class Factory {
// created.  If we design an "extra     public:
// level of indirection" (a "factory       // Factory Method (virtual ctor)
// method") and have clients use it        static Stooge* create( int );
// (instead of "new"), then the last    };
// bit of coupling goes away.  The
// "factory method" (aka "virtual       void main( void ) {
// constructor") can be defined in the     Stooge*  roles[10];
// Stooge base class, or, in a             int      in, j, i = 0;
// separate "factory" class.  Note
// that main() is no longer dependent      while (1) {
// on Stooge derived classes.                 cout << "L(1) M(2) C(3) Go(0): ";
                                              cin >> in;
#include <iostream>                           if ( ! in ) break;
using namespace std;                          roles[i++] = Factory::create(in);
                                           }
class Stooge { public:                     for (j=0; j < i; j++)
   virtual void slapStick() = 0;              roles[j]->slapStick();
};                                         for (j=0; j < i; j++)
                                              delete roles[j];
class Larry : public Stooge { public:   }
   void slapStick() {
      cout << "Larry: poke eyes"        class Larry : public Stooge { public:
         << endl; }                        void slapStick() {
};                                            cout << "Larry: poke eyes"
class Moe : public Stooge { public:              << endl; }
   void slapStick() {                   };
      cout << "Moe: slap head"          class Moe : public Stooge { public:
         << endl; }                        void slapStick() {
};                                            cout << "Moe: slap head"
class Curly : public Stooge { public:            << endl; }
   void slapStick() {                   };
      cout << "Curly: suffer abuse"     class Curly : public Stooge { public:
         << endl; }                        void slapStick() {
};                                            cout << "Curly: suffer abuse"
                                                 << endl; }
void main( void ) {                     };
   Stooge*  roles[10];
   int      in, j, i = 0;               Stooge* Factory::create( int in ) {
                                           if (in == 1)
   cout << "L(1) M(2) C(3) Go(0): ";          return new Larry;
   cin >> in;                              else if (in == 2)
   while (in) {                               return new Moe;
      if (in == 1)                         else
         roles[i++] = new Larry;              return new Curly;
      else if (in == 2)                 }
         roles[i++] = new Moe;
      else                              // L(1) M(2) C(3) Go(0): 1
         roles[i++] = new Curly;        // L(1) M(2) C(3) Go(0): 2
      cout << "L(1) M(2) C(3) Go(0): "; // L(1) M(2) C(3) Go(0): 3
      cin >> in;                        // L(1) M(2) C(3) Go(0): 1
   }                                    // L(1) M(2) C(3) Go(0): 0
   for (j=0; j < i; j++)                // Larry: poke eyes
      roles[j]->slapStick();            // Moe: slap head
   for (j=0; j < i; j++)                // Curly: suffer abuse
      delete roles[j];                  // Larry: poke eyes
}



// Purpose.  Factory Method design pattern demo.
// 
// Discussion.  Frameworks are applications (or subsystems) with "holes"
// in them.  Each framework specifies the infrastructure, superstructure,
// and flow of control for its "domain", and the client of the framework
// may: exercise the framework's default behavior "as is", extend selected
// pieces of the framework, or replace selected pieces.  The Factory
// Method pattern addresses the notion of "creation" in the context of
// frameworks.  In this example, the framework knows WHEN a new document
// should be created, not WHAT kind of Document to create.  The
// "placeholder" Application::CreateDocument() has been declared by the
// framework, and the client is expected to "fill in the blank" for
// his/her specific document(s).  Then, when the client asks for
// Application::NewDocument(), the framework will subsequently call the
// client's MyApplication::CreateDocument().

#include <iostream.h>

/* Abstract base class declared by framework */
class Document {
public:
	Document( char* fn ) { strcpy( name, fn ); }
	virtual void Open()  = 0;
	virtual void Close() = 0;
	char* GetName()      { return name; }
private:
	char  name[20];
};

/* Concrete derived class defined by client */
class MyDocument : public Document {
public:
	MyDocument( char* fn ) : Document(fn) { }
	void Open()   { cout << "   MyDocument: Open()" << endl; }
	void Close()  { cout << "   MyDocument: Close()" << endl; }
};


/* Framework declaration */
class Application {
public:
	Application() : _index(0) { cout << "Application: ctor" << endl; }
	/* The client will call this "entry point" of the framework */
	NewDocument( char* name )  {
		cout << "Application: NewDocument()" << endl;
		/* Framework calls the "hole" reserved for client customization */
		_docs[_index] = CreateDocument( name );
		_docs[_index++]->Open(); }
	OpenDocument()  { }
	void ReportDocs();
	/* Framework declares a "hole" for the client to customize */
	virtual Document* CreateDocument( char* ) = 0;
private:
	int        _index;
	/* Framework uses Document's base class */
	Document*  _docs[10];
};

void Application::ReportDocs() {
	cout << "Application: ReportDocs()" << endl;
	for (int i=0; i < _index; i++)
		cout << "   " << _docs[i]->GetName() << endl; }


/* Customization of framework defined by client */
class MyApplication : public Application {
public:
	MyApplication() { cout << "MyApplication: ctor" << endl; }
	/* Client defines Framework's "hole" */
	Document* CreateDocument( char* fn ) {
		cout << "   MyApplication: CreateDocument()" << endl;
		return new MyDocument( fn ); }
};

void main() {
	/* Client's customization of the Framework */
	MyApplication  myApp;

	myApp.NewDocument( "foo" );
	myApp.NewDocument( "bar" );
	myApp.ReportDocs();
}

// Application: ctor
// MyApplication: ctor
// Application: NewDocument()
//    MyApplication: CreateDocument()
//    MyDocument: Open()
// Application: NewDocument()
//    MyApplication: CreateDocument()
//    MyDocument: Open()
// Application: ReportDocs()
//    foo
//    bar