a_strategy

ÿþ//+------------------------------------------------------------------+

//| PROGRAMMING PATTERNS - STRATEGY                                  |

//| Incapsulate a family of interchangeable algorythms which can be  |

//| modified independently from the client.                          | 

//|                                                                  |

//| OOP CONCEPTS: Abstraction, Encapsulation, Polymorphism,          |

//| Inheritance                                                      |

//|                                                                  |

//| RULES:                                                           |

//| Encapsulate changes                                              |

//| Composition is better than inheritance.                          |

//| Engineer with interfaces, not real classes.                      |

//|                                                                  |

//| A good architecture is extendable, supportable, and reusable.    |

//| Patterns help build hq systems.                                  |

//| Patterns are proven to be good by experience.                    |

//| Patterns are generic solitions for software engineering          |

//| challenges.                                                      |

//| Choose your pattern, don't invent it.                            |

//| Most patterns are designed to manage changes of the architecture.|

//| Most patterns incapsulate variable aspects of the systems.       |

//| Developers know patterns and effectively communicate with each   |

//| other.                                                           |

//+------------------------------------------------------------------+ 



//+------------------------------------------------------------------+

//| BEHAVIOR A INTERFACE                                             |

//+------------------------------------------------------------------+

interface I_BehaviorA

  {

   void Act();

  };

//+------------------------------------------------------------------+

//| BEHAVIOR B INTERFACE                                             |

//+------------------------------------------------------------------+

interface I_BehaviorB

  {

   void Act();

  };

//+------------------------------------------------------------------+

//| REAL BEHAVIOR A - OPTION A                                       |

//+------------------------------------------------------------------+

class C_BehaviorAA : public I_BehaviorA

  {

public:

   void Act() { Print(" "  Doing A the a way"); }

  };

//+------------------------------------------------------------------+

//| REAL BEHAVIOR A - OPTION B                                       |

//+------------------------------------------------------------------+

class C_BehaviorAB : public I_BehaviorA

  {

public:

   void Act() { Print(" "  Doing A the b way"); }

  };

//+------------------------------------------------------------------+

//| REAL BEHAVIOR A - OPTION C                                       |

//+------------------------------------------------------------------+

class C_BehaviorAC : public I_BehaviorA

  {

public:

//--- empty implementation

   void Act() { Print(" "  Doing A is impossible"); }

  };

//+------------------------------------------------------------------+

//| REAL BEHAVIOR B - OPTION A                                       |

//+------------------------------------------------------------------+

class C_BehaviorBA : public I_BehaviorB

  {

public:

   void Act() { Print(" "  Doing B the a way"); }

  };

//+------------------------------------------------------------------+

//| REAL BEHAVIOR B - OPTION B                                       |

//+------------------------------------------------------------------+

class C_BehaviorBB : public I_BehaviorB

  {

public:

   void Act() { Print(" "  Doing B the b way"); }

  };

//+------------------------------------------------------------------+

//| REAL BEHAVIOR C - OPTION C                                       |

//+------------------------------------------------------------------+

class C_BehaviorBC : public I_BehaviorB

  {

public:

//--- empty implementation

   void Act() { Print(" "  Doing B is impossible"); } 

  };

//+------------------------------------------------------------------+

//| ABSTRACT OBJECT                                                  |

//+------------------------------------------------------------------+

class A_Object

  {

public:

                    ~A_Object()

     {

      if(CheckPointer(behavior_a)==POINTER_DYNAMIC) delete behavior_a;

      if(CheckPointer(behavior_b)==POINTER_DYNAMIC) delete behavior_b;

     }

   virtual void      Name()=0;

   void ActA() { behavior_a.Act(); }

   void ActB() { behavior_b.Act(); }

   void ActC() { Print(" "  Doing C the common way"); }

   void SetBehaviorA(I_BehaviorA *b)

     {

      if(CheckPointer(behavior_a)==POINTER_DYNAMIC) delete behavior_a;

      behavior_a=b;

     }

   void SetBehaviorB(I_BehaviorB *b)

     {

      if(CheckPointer(behavior_b)==POINTER_DYNAMIC) delete behavior_b;

      behavior_b=b;

     }



protected:

   I_BehaviorA      *behavior_a;

   I_BehaviorB      *behavior_b;

  };

//+------------------------------------------------------------------+

//| REAL OBJECT A                                                    |

//+------------------------------------------------------------------+

class C_ObjectA : public A_Object

  {

public:

   //--- default behavior 

                     C_ObjectA()

     {

      behavior_a=new C_BehaviorAA();

      behavior_b=new C_BehaviorBA();

     }

   void Name() { Print("Object A"); }

  };

//+------------------------------------------------------------------+

//| REAL OBJECT B                                                    |

//+------------------------------------------------------------------+

class C_ObjectB : public A_Object

  {

public:

   //--- default behavior

                     C_ObjectB()

     {

      behavior_a=new C_BehaviorAB();

      behavior_b=new C_BehaviorBA();

     }

   void Name() { Print("Object B"); }

  };

//+------------------------------------------------------------------+

//| CLIENT                                                           |

//+------------------------------------------------------------------+

void OnStart()

  {

//--- default real object behavior

   A_Object *object_a=new C_ObjectA;

   object_a.Name();

   object_a.ActA();

   object_a.ActB();

   object_a.ActC();

//--- dynamically change behavior

   A_Object *object_b=new C_ObjectB;

   object_b.Name();

   object_b.ActA();

   object_b.ActB();

   object_b.ActC();

   object_b.SetBehaviorA(new C_BehaviorAA);

   object_b.ActA();

   object_b.SetBehaviorA(new C_BehaviorAC);

   object_b.ActA();

//---

   delete object_a;

   delete object_b;

  }

//+------------------------------------------------------------------+

//| OUTPUT                                                           |

//|                                                                  |   

//| Object A                                                         |

//|  "  Doing A the a way                                             |

//|  "  Doing B the a way                                             |

//|  "  Doing C the common way                                        |

//| Object B                                                         |

//|  "  Doing A the b way                                             |

//|  "  Doing B the a way                                             |

//|  "  Doing C the common way                                        |   

//|  "  Doing A the a way                                             |

//|  "  Doing A is impossible                                         |

//+------------------------------------------------------------------+