//+------------------------------------------------------------------+  //|                                        ChainOfResponsibility.mqh |  //|                                    2019-2020, dimitri pecheritsa |  //|                                                 792112@gmail.com |  //+------------------------------------------------------------------+  //| chain of responsibility — behavioral design pattern              |  //+------------------------------------------------------------------+  //   design patterns: elements of reusable object-oriented software  //   gof > erich gamma, richard helm, ralph johnson, john vlissides  //   published — 1994  //+------------------------------------------------------------------+  //| intent                                                           |  //+------------------------------------------------------------------+  //   avoid coupling the sender of a request to its receiver  //    by giving more than one object a chance to handle the request  //   chain the receiving objects and pass the request along the chain  //    until an object handles it  //+------------------------------------------------------------------+  //| benefits                                                         |  //+------------------------------------------------------------------+  //   aspect that may vary > object that can fulfill a request  //   code refactoring  //      problems  //         dependence on specific operations  //         tight coupling  //         extending functionality by subclassing  //      solutions  //         avoid — hard-coded requests  //            also > command  //         decouple — with abstract coupling and layering  //            also > abstract factory, bridge, command, facade,   //             mediator, observer  //         use composition/delegation — for combining behavior  //            also > bridge, composite, decorator, observer, strategy  //+------------------------------------------------------------------+  //| applicability                                                    |  //+------------------------------------------------------------------+  //   more than one object may handle a request,  //    and the handler isn't known a priori  //      the handler should be ascertained automatically  //   you want to issue a request to one of several objects  //    without specifying the receiver explicitly  //   the set of objects that can handle a request  //    should be specified dynamically  //+------------------------------------------------------------------+  //| structure                                                        |  //+------------------------------------------------------------------+  //  //                                        +----------------+  //                                        |                |  //                                        v     successor  |  //      |Client|------------>|    Handler    |-------------+  //                           |---------------|  //                           |HandleRequest()|  //                                   ^  //                                   |  //                      +------------+-------------+  //                      |                          |  //             |ConcreteHandler1|         |ConcreteHandler2|  //             |----------------|         |----------------|  //             |HandleRequest() |         |HandleRequest() |  //  //+------------------------------------------------------------------+  //| a typical object structure                                       |  //+------------------------------------------------------------------+  //  //   |aClient    |  //   |-----------|      |aConcreteHandler|  //   |aHandler *-|----->|----------------|       |aConcreteHandler|  //                      |successor     *-|------>|----------------|  //                                               |successor       |  //  #include <SRC\Patterns\PatternOrganizer.mqh>  namespace ChainOfResponsibility  {  //+------------------------------------------------------------------+  //| participants > handler                                           |  //+------------------------------------------------------------------+  class Handler  //   defines an interface for handling requests  //   (optional) implements the successor link    {  public:     Handler*          successor;     virtual void      HandleRequest(int)=0;                      ~Handler(void);    };  //+------------------------------------------------------------------+  //| participants > handler > destructor                              |  //+------------------------------------------------------------------+  Handler::~Handler(void)    {     delete successor;    }  //+------------------------------------------------------------------+  //| participants > concrete handler                                  |  //+------------------------------------------------------------------+  //   handles requests it is responsible for  //   can access its successor  //   if the concretehandler can handle the request, it does so  //    else it forwards the request to its successor  //+------------------------------------------------------------------+  //| participants > concrete handler > 1                              |  //+------------------------------------------------------------------+  class ConcreteHandler1:public Handler    {  public:     void              HandleRequest(int);    };  //+------------------------------------------------------------------+  //| participants > concrete handler > 1 > handle request             |  //+------------------------------------------------------------------+  void ConcreteHandler1::HandleRequest(int request)    {     if(request==1)        Print("request: ",request,". response: one. handled by: ",&this);     else        if(CheckPointer(successor))          {           Print("request: ",request,". cannot be handled by ",&this,", forwarding to successor...");           successor.HandleRequest(request);          }    }  //+------------------------------------------------------------------+  //| participants > concrete handler > 2                              |  //+------------------------------------------------------------------+  class ConcreteHandler2:public Handler    {  public:     void              HandleRequest(int);    };  //+------------------------------------------------------------------+  //| participants > concrete handler > 2 > handle request             |  //+------------------------------------------------------------------+  void ConcreteHandler2::HandleRequest(int request)    {     if(request==2)        Print("request: ",request,". response: two. handled by: ",&this);     else        if(CheckPointer(successor))          {           Print("request: ",request,". cannot be handled by ",&this,", forwarding to successor...");           successor.HandleRequest(request);          }    }  //+------------------------------------------------------------------+  //| participants > client                                            |  //+------------------------------------------------------------------+  class Client:public ClientExample  //   initiates the request to a concrete handler on the chain    {  public:     string            Output();     void              Run();    };  string Client::Output()    {     return __FUNCTION__;    }  //+------------------------------------------------------------------+  //| collaborations                                                   |  //+------------------------------------------------------------------+  void   Client::Run()  //   request is sent along the chain until concrete handler handles it    {     Handler* h1=new ConcreteHandler1();     Handler* h2=new ConcreteHandler2();     h1.successor=h2;     h1.HandleRequest(1); // will handle the request     h1.HandleRequest(2); // will pass the request to successor  //---     delete h1;    }  }  //+------------------------------------------------------------------+  //| output                                                           |  //+------------------------------------------------------------------+  //   ChainOfResponsibility::Client::Output  //   request: 1. response: one. handled by: 2097152  //   request: 2. cannot be handled by 2097152, forwarding to successor...  //   request: 2. response: two. handled by: 3145728  //+------------------------------------------------------------------+  //| consequences                                                     |  //+------------------------------------------------------------------+  //   reduced coupling  //      object does not know who handles a request  //      object knows that a request will be handled  //      sender does not know receiver  //      object does not know the chain structure  //      simple object interconnections  //      objects do not maintain references to all candidate receivers  //      objects keep a reference to successor only  //   flexibility in assigning responsibilities to objects  //      add/change the chain at run-time  //       combine with subclassing to specialize handlers statically  //   receipt isn't guaranteed  //      request has no explicit receiver  //      request can fall off the end of the chain  //      also when the chain is not configured properly  //+------------------------------------------------------------------+  //| implementation                                                   |  //+------------------------------------------------------------------+  //   successor chain  //      define new links  //      use existing links when the links support the chain  //         saves from defining links explicitly  //         saves space  //         if other structure then define redundant links  //   connecting successors  //      if no preexisting references for defining a chain  //       then handler defines the interface, maintains the successor  //       handler provides a default implementation of handlerequest  //       concrete handler doesn't have to override the forwarding operation  //   representing requests  //      request is a hard-coded operation call  //      convenient and safe  //      can forward only handler's fixed set of requests  //      or use a single handler function with request code as a parameter  //      supports an open-ended requests  //      sender/receiver must agree on encoding  //      requires conditional statements for dispatching the request  //      less safe than direct call  //      can use separate requests that bundle parameters  //      request can represent requests explicitly  //      can subclass new requests  //      subclasses can define different parameters  //      handlers must know the kind of request  //      identify the request by accessor function — returns class id  //      or receiver can use run-time type information  //+------------------------------------------------------------------+  //| related patterns                                                 |  //+------------------------------------------------------------------+  //   composite > component's parent can act as its successor  //+------------------------------------------------------------------+