// Purpose.  Command                    class Deadbeat {
//                                      public:
// Discussion.  On the left, an IOU        Deadbeat( int v ) { cash_ = v; }
// has been encapsulated as a struct,      int payUp( int v ) {
// and TheBoss class is tightly coup-         cash_ -= v;  return v; }
// led to that struct.  On the right,      int rptCash() { return cash_; }
// TheBoss is only coupled to the ab-   private:
// stract class Command.  Lots of pos-     int cash_;
// sible derived classes could be sub-  };
// stituted: IOUs that call payUp() on
// Deadbeats, Checks that call cash()   class Command { public:
// on Banks, Stocks that call redeem()     virtual int execute() = 0;
// on Companies.  Each "command" is a   };
// "token" that gets transfered from
// one holder to another, until some-   class IOU : public Command {
// one chooses to "execute" it.         public:
                                           typedef int (Deadbeat::*Meth)(int);
class Deadbeat { public:                   IOU( Deadbeat* r, Meth a, int m ) {
   Deadbeat( int v ) { cash_ = v; }           obj_ = r;
   int payUp( int v ) {                       mth_ = a;
      cash_ -= v;  return v; }                amt_ = m; }
   int rptCash() { return cash_; }         int execute() {
private:                                      return (obj_->*mth_)( amt_ ); }
   int cash_;                           private:
};                                         Deadbeat*  obj_;
                                           Meth       mth_;
struct IOU {                               int        amt_;
   Deadbeat*  objPtr;                   };
   int (Deadbeat::*funPtr)( int );
   int        amt;                      class Enforcer {
};                                      public:
                                           Enforcer( Command& c ) : cmd_(c) {}
class Enforcer { public:                   Command& collect() { return cmd_; }
   Enforcer( IOU& m ) : mkr_(m) { }     private:
   IOU& collect() { return mkr_; }         Command& cmd_;
private:                                };
   IOU& mkr_;
};                                      class TheBoss {
                                        public:
class TheBoss {                            TheBoss() { cash_ = 1000; }
public:                                    collect( Command& cmd ) {
   TheBoss() { cash_ = 1000; }                cash_ += cmd.execute(); }
   collect( IOU& i ) {                     int rptCash() { return cash_; }
      cash_ +=                          private:
         ((i.objPtr)->*i.funPtr)(i.amt)    int cash_;
   }                                    };
   int rptCash() { return cash_; }
private:                                void main( void )
   int cash_;                           {
};                                         Deadbeat joe(90), tom(90);
                                           IOU one(&joe, &Deadbeat::payUp, 60);
void main( void )                          IOU two(&tom, &Deadbeat::payUp, 70);
{                                          Enforcer quido(one), lucca(two);
   Deadbeat joe(90), tom(90);              TheBoss  don;
   IOU one ={&joe, &Deadbeat::payUp,60}
   IOU two ={&tom, &Deadbeat::payUp,70}    don.collect( quido.collect() );
   Enforcer quido(one), lucca(two);        don.collect( lucca.collect() );
   TheBoss  don;                           cout << "joe has $" << joe.rptCash()
                                           cout << "tom has $" << tom.rptCash()
   don.collect( quido.collect() );         cout << "don has $" << don.rptCash()
   don.collect( lucca.collect() );      }
   cout << "joe has $" << joe.rptCash()
   cout << "tom has $" << tom.rptCash() // joe has $30
   cout << "don has $" << don.rptCash() // tom has $20
}                                       // don has $1130




// Purpose.  Command design pattern

// 1. Create a class that encapsulates some number of the following:
//       a "receiver" object
//       the method to invoke 
//       the arguments to pass
// 2. Instantiate an object for each "callback"
// 3. Pass each object to its future "sender"
// 4. When the sender is ready to callback to the receiver, it calls execute()

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

class Command {                // 1. Create a class that encapsulates an object
   Person*  object;            //    and a member function
   void (Person::*method)();   // a pointer to a member function (the attri-
public:                        //    bute's name is "method")
   Command( Person* obj = 0, void (Person::*meth)() = 0 ) {
      object = obj;            // the argument's name is "meth"
      method = meth;
   }
   void execute() {
      (object->*method)();     // invoke the method on the object
}  };

class Person {
   string   name;
   Command  cmd;               // cmd is a "black box", it is a method invoca-
public:                        //    tion promoted to "full object status"
   Person( string n, Command c ) : cmd( c ) {
      name = n;
   }
   void talk() {               // "this" is the sender, cmd has the receiver
      cout << name << " is talking" << endl;
      cmd.execute();           // ask the "black box" to callback the receiver
   }
   void passOn() {
      cout << name << " is passing on" << endl;
      cmd.execute();           // 4. When the sender is ready to callback to
   }                           //    the receiver, it calls execute()
   void gossip() {
      cout << name << " is gossiping" << endl;
      cmd.execute();
   }
   void listen() {
      cout << name << " is listening" << endl;
}  };

void main( void ) {
   // Fred will "execute" Barney which will result in a call to passOn()
   // Barney will "execute" Betty which will result in a call to gossip()
   // Betty will "execute" Wilma which will result in a call to listen()
   Person wilma(  "Wilma",  Command() );
   // 2. Instantiate an object for each "callback"
   // 3. Pass each object to its future "sender"
   Person betty(  "Betty",  Command( &wilma,  &Person::listen ) );
   Person barney( "Barney", Command( &betty,  &Person::gossip ) );
   Person fred(   "Fred",   Command( &barney, &Person::passOn ) );
   fred.talk();
}

// Fred is talking
// Barney is passing on
// Betty is gossiping
// Wilma is listening




// Purpose.  Simple and "macro" commands
// 
// Discussion.  Encapsulate a request as an object.  SimpleCommand
// maintains a binding between a receiver object and an action stored as a
// pointer to a member function.  MacroCommand maintains a sequence of
// Commands.  No explicit receiver is required because the subcommands
// already define their receiver.  MacroCommand may contain MacroCommands.

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

class Number { public:
   void dubble( int& value ) { value *= 2; }
};

class Command { public: virtual void execute( int& ) = 0; };

class SimpleCommand : public Command {
   typedef void (Number::* Action)(int&);
   Number* receiver;
   Action  action;
public:
   SimpleCommand( Number* rec, Action act ) {
      receiver = rec;
      action = act;
   }
   /*virtual*/ void execute( int& num ) { (receiver->*action)( num ); }
};

class MacroCommand : public Command {
   vector<Command*> list;
public:
   void add( Command* cmd ) { list.push_back( cmd ); }
   /*virtual*/ void execute( int& num ) {
   	for (int i=0; i < list.size(); i++)
         list[i]->execute( num );
}  };

void main( void ) {
   Number object;
   Command* commands[3];
   commands[0] = &SimpleCommand( &object, &Number::dubble );

   MacroCommand two;
   two.add( commands[0] );   two.add( commands[0] );
   commands[1] = &two;

   MacroCommand four;
   four.add( &two );   four.add( &two );
   commands[2] = &four;

   int num, index;
   while (true) {
   	cout << "Enter number selection (0=2x 1=4x 2=16x): ";
      cin >> num >> index;
      commands[index]->execute( num );
      cout << "   " << num << '\n';
}  }

// Enter number selection (0=2x 1=4x 2=16x): 3 0
//    6
// Enter number selection (0=2x 1=4x 2=16x): 3 1
//    12
// Enter number selection (0=2x 1=4x 2=16x): 3 2
//    48
// Enter number selection (0=2x 1=4x 2=16x): 4 0
//    8
// Enter number selection (0=2x 1=4x 2=16x): 4 1
//    16
// Enter number selection (0=2x 1=4x 2=16x): 4 2
//    64




// Purpose.  Command design pattern and inheritance
//
// Discussion.  The Command pattern promotes a deferred method invocation to
// full object status.  Each Command object is a "black box" - it is opaque to
// its holder/user.  Here, a portfolio's heterogeneous collection of financial
// instruments is being treated homogeneously, because, they all inherit from
// a common base class, and, they all have a "convert to currency" method with
// a common signature.

#include <iostream>
using namespace std;

class Instrument { public: virtual ~Instrument() { } };

class IOU : public Instrument {
   int amount;
public:
   IOU( int in ) { amount = in; }
   int payUp() { return amount; }
};

class Check : public Instrument {
   int amount;
public:
   Check( int in ) { amount = in; }
   int cash() { return amount; }
};

class Stock : public Instrument {
   int amount;
public:
   Stock( int in ) { amount = in; }
   int redeem() { return amount; }
};

class Command {
public:
   typedef int (Instrument::*Action)();
   Command( Instrument* o, Action m ) {
      object = o;
      method = m;
   }
   int execute() { return (object->*method)(); }
private:
   Instrument* object;
   Action      method;
};

void main( void ) {
   Command* portfolio[] = {  // old C cast, or new RTTI is required
      &Command( &IOU(100),   (int(Instrument::*)())&IOU::payUp ),
      &Command( &Check(200), static_cast<int(Instrument::*)()>(&Check::cash) ),
      &Command( &Stock(300), static_cast<int(Instrument::*)()>(&Stock::redeem) ) };
   for (int netWorth=0, i=0; i < 3; i++)
      netWorth += portfolio[i]->execute();
   cout << "net worth is now " << netWorth << '\n';
}

// net worth is now 600




// Purpose.  Command design pattern and class template

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

class A {
   int divisor;
public:
   A( int div ) { divisor = div; }
   int divide( int in ) { return in / divisor; }
   int modulus( int in ) { return in % divisor; }
};

class B {
   string str;
public:
   B( string s ) { str = s; }
   string prepend(  string in ) { return in + str; }
   string postpend( string in ) { return str + in; }
};

template <typename CLS, typename ARG>
class Command {
public:
   typedef ARG (CLS::*Action)( ARG );
   Command( CLS* o, Action m, ARG a ) {
      object = o;
      method = m;
      argument = a;
   }
   ARG execute() { return (object->*method)( argument ); }
private:
   CLS*   object;
   Action method;
   ARG    argument;
};

void main( void ) {
   Command<A,int>* list1[4] = {
      &Command<A,int>( &A(3), &A::divide,  16 ),
      &Command<A,int>( &A(3), &A::modulus, 16 ),
      &Command<A,int>( &A(4), &A::divide,  16 ),
      &Command<A,int>( &A(4), &A::modulus, 16 ) };
   for (int i=0; i < 4; i++)
      cout << "numbers are " << list1[i]->execute() << '\n';

   B obj("abc");
   Command<B,string>* list2[4] = {
      new Command<B,string>( &obj, &B::prepend,  "123" ),
      new Command<B,string>( &obj, &B::prepend,  "xyz" ),
      new Command<B,string>( &obj, &B::postpend, "123" ),
      new Command<B,string>( &obj, &B::postpend, "xyz" ) };
   for (i=0; i < 4; i++)
      cout << "strings are " << list2[i]->execute() << '\n';
}

// numbers are 5
// numbers are 1
// numbers are 4
// numbers are 0
// strings are 123abc
// strings are xyzabc
// strings are abc123
// strings are abcxyz




// Purpose.  Command/Adapter design pattern (External Polymorphism demo)

// 1. Specify the new desired interface
// 2. Design a "wrapper" class that can "impedance match" the old to the new
// 3. The client uses (is coupled to) the new interface
// 4. The wrapper/adapter "maps" to the legacy implementation

#include <iostream.h>

class ExecuteInterface { public:                  // 1. Specify the new i/f
   virtual ~ExecuteInterface() { }
   virtual void execute() = 0;
};

template <class TYPE>                             // 2. Design a "wrapper" or
class ExecuteAdapter : public ExecuteInterface {  //    "adapter" class
public:
   ExecuteAdapter( TYPE* o, void (TYPE::*m)() ) { object = o;  method =m; }
   ~ExecuteAdapter()                            { delete object; }
   // 4. The adapter/wrapper "maps" the new to the legacy implementation
   void execute()             /* the new */     { (object->*method)(); }
private:                             
   TYPE* object;                                  // ptr-to-object attribute
   void (TYPE::*method)();    /* the old */       // ptr-to-member-function
};                                                //   attribute

// The old: three totally incompatible classes    // no common base class,
class Fea { public:                               // no hope of polymorphism
   ~Fea()        { cout << "Fea::dtor" << endl; }
   void doThis() { cout << "Fea::doThis()" << endl; }
};

class Feye { public:
   ~Feye()       { cout << "Feye::dtor" << endl; }
   void doThat() { cout << "Feye::doThat()" << endl; }
};

class Pheau { public:
   ~Pheau()          { cout << "Pheau::dtor" << endl; }
   void doTheOther() { cout << "Pheau::doTheOther()" << endl; }
};

/* the new is returned */ ExecuteInterface** initialize() {
   ExecuteInterface** array = new ExecuteInterface*[3]; /* the old is below */
   array[0] = new ExecuteAdapter<Fea>(   new Fea(),     &Fea::doThis       );
   array[1] = new ExecuteAdapter<Feye>(  new Feye(),    &Feye::doThat      );
   array[2] = new ExecuteAdapter<Pheau>( new Pheau(),   &Pheau::doTheOther );
   return array;
}

void main( void ) {
   ExecuteInterface** objects = initialize();

   for (int i=0; i < 3; i++) objects[i]->execute();  // 3. Client uses the new
                                                     //    (polymporphism)
   for (i=0; i < 3; i++) delete objects[i];
   delete objects;
}

// Fea::doThis()
// Feye::doThat()
// Pheau::doTheOther()
// Fea::dtor
// Feye::dtor
// Pheau::dtor




// Purpose.  Command design pattern demo
// 
// Discussion.  Encapsulate a request as an object.  SimpleCommand
// maintains a binding between a receiver object and an action stored as a
// pointer to a member function.  MacroCommand maintains a sequence of
// Commands.  No explicit receiver is required because the subcommands
// already define their receiver.  MacroCommand may contain MacroCommands.

#include <iostream.h>

class Number {
public:
	Number( int value ) { _value = _copy = value; }
	int  getValue()     { return _value; }
	void increment()    { _copy = _value++; }
	void decrement()    { _copy = _value--; }
	void restore()      { _value = _copy; }
	void dubble()       { _copy = _value;  _value = 2 * _value; }
	void half()         { _copy = _value;  _value = _value / 2; }
	void square()       { _copy = _value;  _value = _value * _value; }
private:
	int _value;
	int _copy;
};


class Command {
public:
	virtual void execute() = 0;
	virtual void add( Command* ) { }
protected:
	Command() { }
};

class SimpleCommand : public Command {
public:
	typedef void (Number::* Action)();
	SimpleCommand( Number* receiver, Action action ) {
		_receiver = receiver;
		_action = action; }
	virtual void execute() { (_receiver->*_action)(); }
protected:
    Number* _receiver;
	Action  _action;
};

class MacroCommand : public Command {
public:
	MacroCommand() { _numCommands = 0; }
	void add( Command* cmd ) { _list[_numCommands++] = cmd; }
	virtual void execute();
private:
	Command* _list[10];
	int      _numCommands;
};

void MacroCommand::execute() {
	for (int i=0; i < _numCommands; i++)
		_list[i]->execute();
}

void main() {
	int i;
	cout << "Integer: ";
	cin >> i;
	Number*   object = new Number(i);

	Command*  commands[9];
	commands[1] = new SimpleCommand( object, &Number::increment );
	commands[2] = new SimpleCommand( object, &Number::decrement );
	commands[3] = new SimpleCommand( object, &Number::dubble );
	commands[4] = new SimpleCommand( object, &Number::half );
	commands[5] = new SimpleCommand( object, &Number::square );
	commands[6] = new SimpleCommand( object, &Number::restore );
	commands[7] = new MacroCommand;
	commands[7]->add( commands[1] );
	commands[7]->add( commands[3] );
	commands[7]->add( commands[5] );
	commands[8] = new MacroCommand;
	commands[8]->add( commands[7] );
	commands[8]->add( commands[7] );

	cout << "Exit[0], ++[1], --[2], x2[3], Half[4], Square[5], "
		<< "Undo[6], do3[7] do6[8]: ";
	cin >> i;

	while (i)
	{
		commands[i]->execute();
		cout << "   " << object->getValue() << endl;
		cout << "Exit[0], ++[1], --[2], x2[3], Half[4], Square[5], "
			<< "Undo[6], do3[7] do6[8]: ";
		cin >> i;
	}
}

// Integer: 4
// Exit[0], ++[1], --[2], x2[3], Half[4], Square[5], Undo[6], do3[7] do6[8]: 1
//    5
// Exit[0], ++[1], --[2], x2[3], Half[4], Square[5], Undo[6], do3[7] do6[8]: 3
//    10
// Exit[0], ++[1], --[2], x2[3], Half[4], Square[5], Undo[6], do3[7] do6[8]: 2
//    9
// Exit[0], ++[1], --[2], x2[3], Half[4], Square[5], Undo[6], do3[7] do6[8]: 4
//    4
// Exit[0], ++[1], --[2], x2[3], Half[4], Square[5], Undo[6], do3[7] do6[8]: 5
//    16
// Exit[0], ++[1], --[2], x2[3], Half[4], Square[5], Undo[6], do3[7] do6[8]: 6
//    4
// Exit[0], ++[1], --[2], x2[3], Half[4], Square[5], Undo[6], do3[7] do6[8]: 6
//    4
// Exit[0], ++[1], --[2], x2[3], Half[4], Square[5], Undo[6], do3[7] do6[8]: 7
//    100
// Exit[0], ++[1], --[2], x2[3], Half[4], Square[5], Undo[6], do3[7] do6[8]: 6
//    10
// Exit[0], ++[1], --[2], x2[3], Half[4], Square[5], Undo[6], do3[7] do6[8]: 8
//    940900