// Purpose.  Composite                  // Strategy.  Use recursive composition
                                        // to create a heterogeneous aggregate
#include <string.h>                     // that can be treated homogeneously.
enum NodeType { FileT, DirT };          //
int  g_indent = 0;                      // Benefit.  No more type checking and
                                        // type casting (coupling between Dir
class File {                            // and File is gone, Dir is only
public:                                 // coupled to abstract base class)
   File( char* n ) { type_ = FileT;
      strcpy( name_, n ); }             class AbsFile {
   NodeType getType() { return type_; } public:
   void ls() {                             virtual void ls() = 0;
      for (int i=0; i < g_indent; i++)  protected:
         cout << ' ';                      char        name_[20];
      cout << name_ << endl; }             static int  indent_;
private:                                };
   NodeType  type_;                     int AbsFile::indent_ = 0;
   char      name_[20];
};                                      class File: public AbsFile {
                                        public:
class Dir {                                File( char* n ) {
public:                                       strcpy( name_, n ); }
   Dir( char* n ) { type_ = DirT;          void ls() {
      strcpy( name_, n ); total_ = 0; }       for (int i=0; i < indent_; i++)
   NodeType getType() { return type_; }          cout << ' ';
   void add( File* f ) {                      cout << name_ << endl; }
      files_[total_++] = f;             };
   }
   void ls() {                          class Dir : public AbsFile {
      for (int i=0; i < g_indent; i++)  public:
         cout << ' ';                      Dir( char* n ) {
      cout << name_ << ":" << endl;           strcpy( name_, n ); total_ = 0; }
      g_indent += 3;                       void add( AbsFile* f ) {
      for (int i=0; i < total_; i++)          files_[total_++] = f; }
         if (files_[i]->getType()          void ls() {
               == DirT)                       for (int i=0; i < indent_; i++)
            ((Dir*) files_[i])->ls();            cout << ' ';
         else                                 cout << name_ << ":" << endl;
            files_[i]->ls();                  indent_ += 3;
      g_indent -= 3; }                        for (int i=0; i < total_; i++)
private:                                         files_[i]->ls();
   NodeType  type_;                           indent_ -= 3; }
   char      name_[20];                 private:
   File*     files_[10];                   AbsFile*  files_[10];
   int       total_;                       int       total_;
};                                      };

void main( void )                       void main( void )
{                                       {
   Dir   one("1"), two("2"), thr("3");     Dir   one("1"), two("2"), thr("3");
   File  a("a"), b("b"), c("c"),           File  a("a"), b("b"), c("c"),
         d("d"), e("e");                         d("d"), e("e");
   one.add( &a );                          one.add( &a );
   one.add( (File*) &two );                one.add( &two );
   one.add( &b );                          one.add( &b );
   two.add( &c );                          two.add( &c );
   two.add( &d );                          two.add( &d );
   two.add( (File*) &thr );                two.add( &thr );
   thr.add( &e );                          thr.add( &e );
   one.ls();                               one.ls();
}                                       }

// 1:          //       d               // 1:          //       d
//    a        //       3:              //    a        //       3:
//    2:       //          e            //    2:       //          e
//       c     //    b                  //       c     //    b




// Purpose.  Composite design pattern
//
// 1. Identify the scalar/primitive classes and vector/container classes
// 2. Create an "interface" (lowest common denominator) that can make all
//    concrete classes "interchangeable"
// 3. All concrete classes declare an "is a" relationship to the interface
// 4. All "container" classes couple themselves to the interface (recursive
//    composition, Composite "has a" set of children up the "is a" hierarchy)
// 5. "Container" classes use polymorphism as they delegate to their children

#include <iostream>
#include <vector>
using namespace std;

// 2. Create an "interface" (lowest common denominator)
class Component { public: virtual void traverse() = 0; };

class Leaf : public Component {        // 1. Scalar class   3. "isa" relationship
   int value;
public:
   Leaf( int val ) { value = val; }
   void traverse() { cout << value << ' '; }
};

class Composite : public Component {   // 1. Vector class   3. "isa" relationship
   vector<Component*> children;        // 4. "container" coupled to the interface
public:
   // 4. "container" class coupled to the interface
   void add( Component* ele ) { children.push_back( ele ); }
   void traverse() {
      for (int i=0; i < children.size(); i++)
         // 5. Use polymorphism to delegate to children
         children[i]->traverse();
}  };

void main( void ) {
   Composite containers[4];

   for (int i=0; i < 4; i++)
      for (int j=0; j < 3; j++)
         containers[i].add( new Leaf( i * 3 + j ) );

   for (i=1; i < 4; i++)
      containers[0].add( &(containers[i]) );

   for (i=0; i < 4; i++) {
      containers[i].traverse();
      cout << endl;
}  }

// 0 1 2 3 4 5 6 7 8 9 10 11
// 3 4 5
// 6 7 8
// 9 10 11




// Purpose.  Composite design pattern - multiple container classes

#include <iostream>
#include <vector>
using namespace std;

class Component { public: virtual void traverse() = 0; };

class Primitive : public Component {
   int value;
public:
   Primitive( int val ) { value = val; }
   void traverse()      { cout << value << "  "; }
};

class Composite : public Component {
   vector<Component*> children;
   int                value;
public:
   Composite( int val )     { value = val; }
   void add( Component* c ) { children.push_back( c ); }
   void traverse() {
      cout << value << "  ";
      for (int i=0; i < children.size(); i++)
          children[i]->traverse();
}  };

class Row : public Composite { public:     // Two different kinds of "con-
   Row( int val ) : Composite( val ) { }   // tainer" classes.  Most of the
   void traverse() {                       // "meat" is in the Composite
      cout << "Row";                       // base class.
      Composite::traverse();
}  };

class Column : public Composite { public:
   Column( int val ) : Composite( val ) { }
   void traverse() {
      cout << "Col";
      Composite::traverse();
}  };

void main( void ) {
      Row    first( 1 );                     // Row1
      Column second( 2 );                    //   |
      Column third( 3 );                     //   +-- Col2
      Row    fourth( 4 );                    //   |     |
      Row    fifth( 5 );                     //   |     +-- 7
      first.add( &second );                  //   +-- Col3
      first.add( &third  );                  //   |     |
      third.add( &fourth );                  //   |     +-- Row4
      third.add( &fifth  );                  //   |     |     |
      first.add(  &Primitive( 6 ) );         //   |     |     +-- 9
      second.add( &Primitive( 7 ) );         //   |     +-- Row5
      third.add(  &Primitive( 8 ) );         //   |     |     |
      fourth.add( &Primitive( 9 ) );         //   |     |     +-- 10
      fifth.add(  &Primitive(10 ) );         //   |     +-- 8
      first.traverse();  cout << '\n';       //   +-- 6
}

// Row1  Col2  7  Col3  Row4  9  Row5  10  8  6




// Purpose.  Composite and Prototype - lightweight persistence

#pragma warning( disable : 4786 )
#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <fstream>
using namespace std;

class Component { public:
   virtual ~Component() { }
   virtual void       traverse() = 0;
   virtual Component* clone() = 0;
   virtual void       initialize( ifstream& ) = 0;
};

namespace Factory {
   map<string,Component*> hash;
   void add( string s, Component* c ) { hash[s] = c; }
   Component* makeComponent( string name ) { return hash[name]->clone(); }
}

class Leaf : public Component {
   string value;
public:
   ~Leaf()                           { cout << 'd' << value << ' '; }
   /*virtual*/ void       traverse() { cout << value << ' '; }
   /*virtual*/ Component* clone()    { return new Leaf(); }
   /*virtual*/ void       initialize( ifstream& is ) { is >> value; }
};

class Composite : public Component {
   vector<Component*> children;
   string             value;
public:
   ~Composite() {
      cout << 'd' << value << ' ';
      for (int i=0; i < children.size(); i++)
          delete children[i];
   }
   void add( Component* c ) { children.push_back( c ); }
   /*virtual*/ void traverse() {
      cout << value << ' ';
      for (int i=0; i < children.size(); i++)
          children[i]->traverse();
   }
   /*virtual*/ Component* clone() { return new Composite(); }
   /*virtual*/ void       initialize( ifstream& is ) {
      is >> value;
      string str, delim( "/"+value );
      is >> str;
      while (str != delim) {
         add( Factory::makeComponent( str ) );
         children[children.size()-1]->initialize( is );
         is >> str;
}  }  };

void main( void ) {
   Factory::add( "comp", new Composite() );
   Factory::add( "leaf", new Leaf() );
   ifstream is( "compositeCreate.txt" );
   string str;
   is >> str;
   Component* root = Factory::makeComponent( str );
   root->initialize( is );
   root->traverse();  cout << '\n';
   delete root;       cout << '\n';
}

/***
comp a leaf 1 comp b comp d leaf 8 leaf 9 /d leaf 4 comp e leaf 10
leaf 11 leaf 12 /e leaf 2 comp c leaf 5 leaf 6 leaf 7 /c /b leaf 3 /a
***/

// a 1 b d 8 9 4 e 10 11 12 2 c 5 6 7 3
// da d1 db dd d8 d9 d4 de d10 d11 d12 d2 dc d5 d6 d7 d3