// Purpose.  Visitor design pattern lab
// 
// Problem.  "Open for extension, closed for modification" is a dominant
// principle of object-oriented design.  The Composite design pattern is an
// excellent strategy for designing recursively, or hierarchically, related
// collections of objects.  Once the Composite hierarchy is produced, adding
// new methods (that operate on the hierarchy) requires either: violating the
// "open-closed" principle, or, writing client code that has to do "type
// checking" and "type casting" in order to "recover lost type information".
// This latter approach is modeled below in the cat() and wc() methods of
// class Client.  The Visitor pattern specifies that a single access method
// be added to the Composite hierarchy.  Once this is done, many new methods
// can be added in the future, the "open-closed" principle can be enforced,
// and, the ugly code for "recovering lost type information" can be avoided.
// 
// Assignment.
// o Define a Visitor base class with 3 pure virtual member functions:
//      void visit( Primitive* ) = 0;
//      void visit( Link* )      = 0;
//      void visit( Composite* ) = 0;
// o Define 2 derived classes of Visitor (CatVisitor and WcVisitor) that
//   encapsulate the ugly code in class Client.  The implementation of each of
//   the overloaded visit() methods will be the body of one of the conditional
//   clauses of the existing cat() and wc() methods.
// o Add a pure virtual member function to Component:
//      void accept( Visitor& ) = 0;
// o Define accept() in all 3 Component derived classes as:
//      void accept( Visitor& v ) { v.visit( this ); }
// o Create CatVisitor and WcVisitor objects in main().
// o The body of main()'s "for" loop will become:
//      array[i]->accept( aCatObj );
//      array[i]->accept( aWcObj );
// o Get rid of compType, returnType(), Client.

#include <iostream.h>
enum compType { PrimitiveT, LinkT, CompositeT };

class Component {
public:
   virtual compType  returnType()       = 0;
   virtual void      streamOut()        = 0;
   virtual void      add( Component* )  { };
};

class Primitive : public Component {
public:
   Primitive( int id )   { identity = id; }
   compType returnType() { return PrimitiveT; }
   void     streamOut()  { cout << identity << " "; }
private:
   int identity;
};

class Link : public Component {
public:
   Link( Component& ele ) : linkElement(ele)  { }
   compType   returnType()                    { return LinkT; }
   void       streamOut()                     { linkElement.streamOut(); }
   Component& getSubject()                    { return linkElement; }
private:
   Component& linkElement;
};

class Composite : public Component {
public:
   Composite()                    { index = 0; }
   compType returnType()          { return CompositeT; }
   void     add( Component* ele ) { array[index++] = ele; }
   void     streamOut() {
      for (int i=0; i < index; i++)
         array[i]->streamOut();
   }
private:
   int         index;
   Component*  array[20];
};

class Client {
public:
   void cat( Component* node ) {
      if (node->returnType() == PrimitiveT) {
         cout << "cat: ";   node->streamOut();   cout << endl;
      } else if (node->returnType() == CompositeT)
         cout << "cat: Can't cat a directory." << endl;
      else if (node->returnType() == LinkT)
         cat(&(((Link*)node)->getSubject()));
   }
   void wc( Component* node ) {
      if (node->returnType() == PrimitiveT) {
          cout << "wc: ";   node->streamOut();   cout << endl;
      } else if (node->returnType() == CompositeT)
         cout << "wc: Can't wc a directory." << endl;
      else if (node->returnType() == LinkT)
         wc(&(((Link*)node)->getSubject()));
   }
};

void main( void ) {
   Composite        dir;
   Primitive        file1(1), file2(2);
   Link             alias( file1 );
   Component*       array[4];
   Client           doFile;
                    
   dir.add( &file1 );
   dir.add( &file2 );
   dir.add( &alias );
   dir.streamOut();
   cout << endl;

   array[0] = &dir;
   array[1] = &file1;
   array[2] = &file2;
   array[3] = &alias;
   for (int i = 0; i < 4; i++) {
      doFile.cat( array[i] );
      doFile.wc( array[i] );
}  }

// 1 2 1 
// cat: Can't cat a directory.
// wc: Can't wc a directory.
// cat: 1 
// wc: 1 
// cat: 2 
// wc: 2 
// cat: 1 
// wc: 1