Decorator - structural design pattern

//+------------------------------------------------------------------+
//|                                                    Decorator.mqh |
//|                                    2019-2020, dimitri pecheritsa |
//|                                                 792112@gmail.com |
//+------------------------------------------------------------------+
//| decorator < structural design pattern                            |
//+------------------------------------------------------------------+
//   design patterns: elements of reusable object-oriented software
//   gof > erich gamma, richard helm, ralph johnson, john vlissides
//   published in 1994
//+------------------------------------------------------------------+
//| intent                                                           |
//+------------------------------------------------------------------+
//   attach — additional responsibilities — to an object dynamically
//   provide — flexible alternative to subclassing — for extending
//    functionality
//+------------------------------------------------------------------+
//| benefits                                                         |
//+------------------------------------------------------------------+
//   variable aspect > responsibilities of an object without subclassing
//   code refactoring
//      inability to alter classes conveniently > also > adapter, visitor
//      extending functionality by subclassing
//         solution > composition/delegation for combining behavior
//         also > bridge, chain of responsibility, composite,
//          observer, strategy
//+------------------------------------------------------------------+
//| applicability                                                    |
//+------------------------------------------------------------------+
//   add responsibilities — to individual objects —
//      dynamically and transparently — without affecting other objects
//   for responsibilities that can be withdrawn
//   when extension by subclassing is impractical
//      sometimes a large number of independent extensions are possible
//       and would produce an explosion of subclasses to support
//       every combination
//      or a class definition may be hidden
//      or otherwise unavailable for subclassing
//+------------------------------------------------------------------+
//| structure                                                        |
//+------------------------------------------------------------------+
//
//                  | Component |<------------------------------+
//                  |-----------|                               |
//                  |Operation()|                               |
//                        ^                                     |
//                        |                                     |
//            +-----------+-------------+                       |
//            |                         |             component |
//   |ConcreteComponent|    |       Decorator       |-----------+
//   |-----------------|    |-----------------------|
//   |Operation()      |    |Operation()            |
//                          |  component.Operation()|
//                                      ^
//                                      |
//                        +-------------+----------+
//                        |                        |
//               |ConcreteDecoratorA|  |   ConcreteDecoratorB  |
//               |------------------|  |-----------------------|
//               |Operation()       |  |Operation()            |
//               |------------------|  | Decorator::Operation()|
//               |added_state       |  | AddedBehavior()       |
//                                     |AddedBehavior()        |
//
#include <SRC\Patterns\PatternOrganizer.mqh>
namespace Decorator
{
//+------------------------------------------------------------------+
//| participants > component                                         |
//+------------------------------------------------------------------+
class Component
//   defines — interface for objects
//      can have responsibilities added to them dynamically
  {
public:
   virtual void      Operation(void)=0;
  };
//+------------------------------------------------------------------+
//| participants > decorator                                         |
//+------------------------------------------------------------------+
class Decorator:public Component
//   maintains — reference to a component object
//   defines — interface — conforms to component's interface
  {
public:
   Component*        component;
   void              Operation(void);
  };
//+------------------------------------------------------------------+
//| participants > decorator                                         |
//+------------------------------------------------------------------+
void Decorator::Operation(void)
  {
   if(CheckPointer(component)>0)
     {
      component.Operation();
     }
  }
//+------------------------------------------------------------------+
//| participants > concrete component                                |
//+------------------------------------------------------------------+
class ConcreteComponent:public Component
//   defines — object — to which additional responsibilities can be attached
  {
public:
   void              Operation(void);
  };
//+------------------------------------------------------------------+
//| participants > concrete component                                |
//+------------------------------------------------------------------+
void ConcreteComponent::Operation(void)
  {
   Print("concrete operation");
  }
//+------------------------------------------------------------------+
//| participants > concrete decorator                                |
//+------------------------------------------------------------------+
//   adds responsibilities to the component
//+------------------------------------------------------------------+
//| participants > concrete decorator > a                            |
//+------------------------------------------------------------------+
class ConcreteDecoratorA:public Decorator
  {
protected:
   string            added_state;
public:
                     ConcreteDecoratorA(void);
   void              Operation(void);
  };
//+------------------------------------------------------------------+
//| participants > concrete decorator > a                            |
//+------------------------------------------------------------------+
ConcreteDecoratorA::ConcreteDecoratorA(void):
   added_state("added state")
  {
  }
//+------------------------------------------------------------------+
//| participants > concrete decorator > a                            |
//+------------------------------------------------------------------+
void ConcreteDecoratorA::Operation(void)
  {
   Decorator::Operation();
   Print(added_state);
  }
//+------------------------------------------------------------------+
//| participants > concrete decorator > b                            |
//+------------------------------------------------------------------+
class ConcreteDecoratorB:public Decorator
  {
public:
   void              AddedBehavior(void);
   void              Operation(void);
  };
//+------------------------------------------------------------------+
//| participants > concrete decorator > b                            |
//+------------------------------------------------------------------+
void ConcreteDecoratorB::AddedBehavior(void)
  {
   Print("added behavior");
  }
//+------------------------------------------------------------------+
//| participants > concrete decorator > b                            |
//+------------------------------------------------------------------+
void ConcreteDecoratorB::Operation(void)
  {
   Decorator::Operation();
   AddedBehavior();
  }
//+------------------------------------------------------------------+
//| participants > client                                            |
//+------------------------------------------------------------------+
class Client:public ClientExample
  {
public:
   string            Output(void);
   void              Run(void);
  };
string Client::Output(void) {return __FUNCTION__;}
//+------------------------------------------------------------------+
//| collaborations                                                   |
//+------------------------------------------------------------------+
void Client::Run(void)
//   decorator
//      forwards — requests — to its component object
//      it may optionally perform — additional operations before and
//       after forwarding the request
  {
   Component* component=new ConcreteComponent();
   Decorator* decorator_a=new ConcreteDecoratorA();
   Decorator* decorator_b=new ConcreteDecoratorB();
   decorator_a.component=component;
   decorator_b.component=decorator_a;
   decorator_b.Operation();
//---
   delete component;
   delete decorator_a;
   delete decorator_b;
  }
}
//+------------------------------------------------------------------+
//| output                                                           |
//+------------------------------------------------------------------+
//   Decorator::Client::Output
//   concrete operation
//   added state
//   added behavior
//+------------------------------------------------------------------+
//| consequences                                                     |
//+------------------------------------------------------------------+
//   more flexibility than static inheritance
//      responsibilities can be added and removed at run-time
//       simply by attaching and detaching them
//      easy to add a property twice
//   avoids feature-laden classes high up in the hierarchy
//      add functionality incrementally
//         define — new decorators independently
//            from the classes of objects they extend
//            even for unforeseen extensions
//   a decorator and its component aren't identical
//   lots of little objects
//+------------------------------------------------------------------+
//| implementation                                                   |
//+------------------------------------------------------------------+
//   interface conformance > decorator-component
//   omitting the abstract decorator class — if single responsibility
//   keeping components lightweight
//   changing the skin of an object versus changing its guts > strategy
//+------------------------------------------------------------------+
//| related patterns                                                 |
//+------------------------------------------------------------------+
//   adapter > will give an object a completely — new interface
//      decorator > changes object's responsibilities, not its interface
//   composite
//      decorator — is a degenerate composite with only one component —
//       not intended for object aggregation
//   strategy > change the guts of an object
//      decorator > change the skin of an object
//+------------------------------------------------------------------+