Watch how to download trading robots for free
Interesting script?
So post a link to it -
let others appraise it
You liked the script? Try it in the MetaTrader 5 terminal
Libraries

Command - behavioral design pattern - library for MetaTrader 5

DMITRII PECHERITSA

Views:
639
Rating:
votes: 5
Published:
2020.10.07 11:28
\MQL5\Include\SRC\Patterns\\MQL5\Include\SRC\Patterns\Behavioral\
Command.mqh (25.79 KB)view
//+------------------------------------------------------------------+
//|                                                      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
//+------------------------------------------------------------------+


Pro Traders see RISK as Percentage Pro Traders see RISK as Percentage

Most traders keep losing money because they focus on money rather than planning their trades based on Percentage risk.

Chain of responsibility - behavioral design pattern Chain of responsibility - behavioral design pattern

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

Gann high/low activator (simple) Gann high/low activator (simple)

Short description.

Gann high/low activator (oscillator) Gann high/low activator (oscillator)

Gann high/low activator (oscillator)