// Purpose.  Decorator design pattern

// 1. Create a "lowest common denominator" that makes classes interchangeable
// 2. Create a second level base class for optional functionality
// 3. "Core" class and "Decorator" class declare an "isa" relationship
// 4. Decorator class "hasa" instance of the "lowest common denominator"
// 5. Decorator class delegates to the "hasa" object
// 6. Create a Decorator derived class for each optional embellishment
// 7. Decorator derived classes delegate to base class AND add extra stuf
// 8. Client has the responsibility to compose desired configurations

#include <iostream>
using namespace std;

class Widget { public: virtual void draw() = 0; };  // 1. "lowest common denom"

class TextField : public Widget {                   // 3. "Core" class & "isa"
   int width, height;
public:
   TextField( int w, int h ) { width  = w;  height = h; }
   /*virtual*/ void draw() { cout << "TextField: " << width << ", " << height << '\n'; }
};
                                                    // 2. 2nd level base class
class Decorator : public Widget {                   // 3. "isa" relationship
   Widget* wid;                                     // 4. "hasa" relationship
public:
   Decorator( Widget* w )  { wid = w; }
   /*virtual*/ void draw() { wid->draw(); }         // 5. Delegation
};

class BorderDecorator : public Decorator { public:  // 6. Optional embellishment
   BorderDecorator( Widget* w ) : Decorator( w ) { }
   /*virtual*/ void draw() {
      Decorator::draw();                            // 7. Delegate to base class
      cout << "   BorderDecorator" << '\n';         //    and add extra stuff
}  };

class ScrollDecorator : public Decorator { public:  // 6. Optional embellishment
   ScrollDecorator( Widget* w ) : Decorator( w ) { }
   /*virtual*/ void draw() {
      Decorator::draw();                            // 7. Delegate to base class
      cout << "   ScrollDecorator" << '\n';         //    and add extra stuff
}  };

void main( void ) {
   // 8. Client has the responsibility to compose desired configurations
   Widget* aWidget = new BorderDecorator(
                        new BorderDecorator(
                           new ScrollDecorator(
                              new TextField( 80, 24 ))));
   aWidget->draw();
}

// TextField: 80, 24
//    ScrollDecorator
//    BorderDecorator
//    BorderDecorator




// Purpose.  Inheritance run amok

#include <iostream>
using namespace std;

class A { public:
   virtual void doIt() { cout << 'A'; }
};

class AwithX : public A {
   void doX() { cout << 'X'; }
public:
   /*virtual*/ void doIt() {
      A::doIt();
      doX();
}  };

class AwithY : public A {
protected:
   void doY() { cout << 'Y'; }
public:
   /*virtual*/ void doIt() {
      A::doIt();
      doY();
}  };

class AwithZ : public A {
protected:
   void doZ() { cout << 'Z'; }
public:
   /*virtual*/ void doIt() {
      A::doIt();
      doZ();
}  };

class AwithXY : public AwithX, public AwithY { public:
   /*virtual*/ void doIt() {
      AwithX::doIt();
      AwithY::doY();
}  };

class AwithXYZ : public AwithX, public AwithY, public AwithZ { public:
   /*virtual*/ void doIt() {
      AwithX::doIt();
      AwithY::doY();
      AwithZ::doZ();
}  };

void main( void ) {
   AwithX    anX;
   AwithXY   anXY;
   AwithXYZ  anXYZ;
   anX.doIt();    cout << '\n';
   anXY.doIt();   cout << '\n';
   anXYZ.doIt();  cout << '\n';
}

// AX
// AXY
// AXYZ




// Purpose.  Replacing inheritance with wrapping-delegation
//
// Discussion.  Use aggregation instead of inheritance to implement
// embellishments to a "core" object.  Client can dynamically compose
// permutations, instead of the architect statically wielding multiple
// inheritance.

#include <iostream>
using namespace std;

class I { public:
   virtual ~I() { }
   virtual void doIt() = 0;
};

class A : public I { public:
   ~A() { cout << "A dtor" << '\n'; }
   /*virtual*/ void doIt() { cout << 'A'; }
};

class D : public I {
   I* wrappee;
public:
   D( I* inner )           { wrappee = inner; }
   ~D()                    { delete wrappee; }
   /*virtual*/ void doIt() { wrappee->doIt(); }
};

class X : public D { public:
   X( I* core ) : D(core) { }
   ~X() { cout << "X dtor" << "   "; }
   /*virtual*/ void doIt() { D::doIt();  cout << 'X'; }
};

class Y : public D { public:
   Y( I* core ) : D(core) { }
   ~Y() { cout << "Y dtor" << "   "; }
   /*virtual*/ void doIt() { D::doIt();  cout << 'Y'; }
};

class Z : public D { public:
   Z( I* core ) : D(core) { }
   ~Z() { cout << "Z dtor" << "   "; }
   /*virtual*/ void doIt() { D::doIt();  cout << 'Z'; }
};

void main( void ) {
   I* anX = new X( new A );
   I* anXY = new Y( new X( new A ) );
   I* anXYZ = new Z( new Y( new X( new A ) ) );
   anX->doIt();    cout << '\n';
   anXY->doIt();   cout << '\n';
   anXYZ->doIt();  cout << '\n';
   delete anX;   delete anXY;   delete anXYZ;
}

// AX
// AXY
// AXYZ
// X dtor   A dtor
// Y dtor   X dtor   A dtor
// Z dtor   Y dtor   X dtor   A dtor




// Purpose.  Decorator - encoding and decoding layers of header/packet/trailer

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

class Interface { public:
   virtual ~Interface() { }
   virtual void write( string& ) = 0;
   virtual void read(  string& ) = 0;
};

class Core : public Interface { public:
   ~Core() { cout << "dtor-Core\n"; }
   /*virtual*/ void write( string& b ) { b += "MESSAGE|"; }
   /*virtual*/ void read( string& );
};

class Decorator : public Interface {
   Interface* inner;
public:
   Decorator( Interface* c ) { inner = c; }
   ~Decorator()              { delete inner; }
   /*virtual*/ void write( string& b ) { inner->write( b ); }
   /*virtual*/ void read(  string& b ) { inner->read( b ); }
};

class Wrapper : public Decorator {
   string forward, backward;
public:
   Wrapper( Interface* c, string str ) : Decorator(c) {
      forward = str;
      string::reverse_iterator it;
      it = str.rbegin();
      for ( ; it != str.rend(); ++it)
         backward += *it;
   }
   ~Wrapper() { cout << "dtor-" << forward << "  "; }
   void write( string& );
   void read(  string& );
};

void main( void ) {
   Interface* object = new Wrapper( new Wrapper( new Wrapper(
                          new Core(), "123" ), "abc" ), "987" );
   string buf;
   object->write( buf );
   cout << "main: " << buf << endl;
   object->read( buf );
   delete object;
}

// main: 987]abc]123]MESSAGE|321]cba]789]
// Wrapper: 987
// Wrapper: abc
// Wrapper: 123
// Core: MESSAGE
// Wrapper: 321
// Wrapper: cba
// Wrapper: 789
// dtor-987  dtor-abc  dtor-123  dtor-Core

void Core::read(string& b) {
   int num = b.find_first_of( '|' );
   cout << "Core: " << b.substr(0,num) << '\n';
   b = b.substr(num+1);
}

void Wrapper::write( string& b ) {
   b += forward + "]";
   Decorator::write( b );
   b += backward + "]";
}

void Wrapper::read( string& b ) {
   int num = b.find_first_of( ']' );
   cout << "Wrapper: " << b.substr(0,num) << '\n';
   b = b.substr(num+1);
   Decorator::read( b );
   num = b.find_first_of( ']' );
   cout << "Wrapper: " << b.substr(0,num) << '\n';
   b = b.substr(num+1);
}