//+------------------------------------------------------------------+ //| Command.mqh | //| 2019-2020, dimitri pecheritsa | //| 792112@gmail.com | //+------------------------------------------------------------------+ //| command — behavioral design pattern | //+------------------------------------------------------------------+ // design patterns: elements of reusable object-oriented software // gof > erich gamma, richard helm, ralph johnson, john vlissides // published — 1994 //+------------------------------------------------------------------+ //| intent | //+------------------------------------------------------------------+ // encapsulate a request as an object // thereby letting you parameterize clients with different requests // queue or log requests, and support undoable operations //+------------------------------------------------------------------+ //| benefits | //+------------------------------------------------------------------+ // variable aspect > when and how a request is fulfilled // refactoring // problems // dependence on specific operations // tight coupling // solutions // avoid hard-coded requests > also > chain of responsibility // decouple with abstract coupling and layering // also > abstract factory, bridge, chain of responsibility, // facade, mediator, observer //+------------------------------------------------------------------+ //| applicability | //+------------------------------------------------------------------+ // parameterize objects by an action to perform // specify, queue, and execute requests at different times // command is independent of the original request // support undo // support change log // reapply after a system crash // add load/store to command // reload from disk // reexecute with the execute // structure a system around high-level operations // built on primitives operations //+------------------------------------------------------------------+ //| structure | //+------------------------------------------------------------------+ // // |Client| |Invoker|o------------------->| Command | // | | |---------| // | |Execute()| // | +------->|Receiver| ^ // |--------| receiver | // | |Action()|<--------------| ConcreteCommand | // |------------------| // | |Execute() | // | receiver.Action()| // | |------------------| // + - - - - - - - - - - - - - - - - - >|state | // #include <SRC\Patterns\PatternOrganizer.mqh> namespace Command { //+------------------------------------------------------------------+ //| participants > receiver | //+------------------------------------------------------------------+ class Receiver // knows how to perform the request operations // any class may be a receiver { public: Receiver(void); Receiver(Receiver&); void Action(void); }; //+------------------------------------------------------------------+ //| participants > receiver > default | //+------------------------------------------------------------------+ Receiver::Receiver(void) { } //+------------------------------------------------------------------+ //| participants > receiver > copy constructor | //+------------------------------------------------------------------+ Receiver::Receiver(Receiver &src) { } //+------------------------------------------------------------------+ //| participants > receiver > action | //+------------------------------------------------------------------+ void Receiver::Action(void) { Print("receiver ",&this," action"); } //+------------------------------------------------------------------+ //| participants > command | //+------------------------------------------------------------------+ class Command // declares operation interface { protected: Receiver* m_receiver; public: Command(Receiver*); ~Command(void); virtual void Execute(void)=0; }; //+------------------------------------------------------------------+ //| participants > command > constructor | //+------------------------------------------------------------------+ Command::Command(Receiver* receiver) { m_receiver=new Receiver(receiver); Print("receiver ",receiver," accepted by command ",&this); } //+------------------------------------------------------------------+ //| participants > command > destructor | //+------------------------------------------------------------------+ Command::~Command(void) { if(CheckPointer(m_receiver)==1) { delete m_receiver; } } //+------------------------------------------------------------------+ //| participants > concrete command | //+------------------------------------------------------------------+ class ConcreteCommand:public Command // receiver/action binding // implements execute() by calling receiver operation { protected: int m_state; public: ConcreteCommand(Receiver*); void Execute(void); }; //+------------------------------------------------------------------+ //| participants > concrete command > constructor | //+------------------------------------------------------------------+ ConcreteCommand::ConcreteCommand(Receiver* receiver): Command(receiver), m_state(0) { Print("command ",&this," state: ",m_state); } //+------------------------------------------------------------------+ //| participants > concrete command > execute | //+------------------------------------------------------------------+ void ConcreteCommand::Execute(void) { Print("command executes receiver ",m_receiver); m_receiver.Action(); m_state=1; Print("command ",&this," state: ",m_state); } //+------------------------------------------------------------------+ //| participants > invoker | //+------------------------------------------------------------------+ class Invoker // asks the command to carry out the request { public: ~Invoker(void); void StoreCommand(Command*); void Execute(void); protected: Command* m_command; }; //+------------------------------------------------------------------+ //| participants > invoker > destructor | //+------------------------------------------------------------------+ Invoker::~Invoker(void) { if(CheckPointer(m_command)==1) { delete m_command; } } //+------------------------------------------------------------------+ //| participants > invoker > command | //+------------------------------------------------------------------+ void Invoker::StoreCommand(Command* command) { m_command=command; Print("command ",m_command," stored"); } //+------------------------------------------------------------------+ //| participants > invoker > execute | //+------------------------------------------------------------------+ void Invoker::Execute(void) { Print("executing command ",m_command); m_command.Execute(); } //+------------------------------------------------------------------+ //| participants > client | //+------------------------------------------------------------------+ class Client:public ClientExample // creates a concrete command object and sets its receiver { public: string Output(void); void Run(void); }; string Client::Output(void) { return __FUNCTION__; } //+------------------------------------------------------------------+ //| collaborations | //+------------------------------------------------------------------+ void Client::Run(void) // client // creates a concrete command // specifies its receiver // invoker // stores the concrete command requests by calling execute() // command undoable // concrete command stores state prior to execute() // // aReceiver aClient aCommand anInvoker // | | | | // | | | // | | |newCommand(aReceiver) | | // | | |- - - - - - - - - - - ->| | | // | | | | | // | | |StoreCommand(aCommand) | | // | | |-------------------------|------------->| | // | | | | | // | | | | // / / / / // / / / / // | | | | // | | | Execute()| | // | | Action()| |<------------| | // | |<--------|-------------------------| | | | // | | | | { Receiver receiver; Invoker invoker; invoker.StoreCommand(new ConcreteCommand(&receiver)); invoker.Execute(); } } //+------------------------------------------------------------------+ //| output | //+------------------------------------------------------------------+ // Command::Client::Output // receiver 2097152 accepted by command 4194304 // command 4194304 state: 0 // command 4194304 stored // executing command 4194304 // command executes receiver 5242880 // receiver 5242880 action // command 4194304 state: 1 //+------------------------------------------------------------------+ //| consequences | //+------------------------------------------------------------------+ // decouple operation's caller/performer // commands are first-class manipulateable/extendable objects // assemble commands into a composite command // easy to add new commands //+------------------------------------------------------------------+ //| implementation | //+------------------------------------------------------------------+ // how intelligent is a command // binds receiver/actions // delegates nothing to receiver // commands are independent of the existing classes // no receiver exists // command knows receiver // commands can find receiver dynamically // undo and redo // concrete command stores additional state // receiver // operation arguments // receiver's original values that can change receiver // provides the recover operations // multiple-level // history list of sequences of commands // reverse-execute to cancel // maybe copy an undoable command before putting it on list // error accumulation in undo // delay can be a problem // errors can accumulate // use memento to store more original state in the command // for recover // templates for non-undoable/no argument commands //+------------------------------------------------------------------+ //| related patterns | //+------------------------------------------------------------------+ // composite > implement macrocommands // memento > keep state the command requires to undo its effect // prototype > a command that must be copied // before being placed on the history list //+------------------------------------------------------------------+
