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

Composite - structural design pattern - library for MetaTrader 5

DMITRII PECHERITSA

Views:
613
Rating:
votes: 7
Published:
2020.09.02 09:25
Pattern.mq5 (1.26 KB)view
\MQL5\Include\SRC\Patterns\\MQL5\Include\SRC\Patterns\Structural\
Composite.mqh (13.09 KB)view
//+------------------------------------------------------------------+
//|                                                    Composite.mqh |
//|                                    2019-2020, dimitri pecheritsa |
//|                                                 792112@gmail.com |
//+------------------------------------------------------------------+
//| src > patterns > structural > composite                          |
//+------------------------------------------------------------------+
//   design patterns: elements of reusable object-oriented software
//   gof > erich gamma, richard helm, ralph johnson, john vlissides
//   published in 1994
//+------------------------------------------------------------------+
//| intent                                                           |
//+------------------------------------------------------------------+
//   object tree > represents > part-whole hierarchies
//   client > treats uniformly > objects and compositions of objects
//+------------------------------------------------------------------+
//| benefits                                                         |
//+------------------------------------------------------------------+
//   variable aspect > structure and composition of an object
//   refactoring > problem > extending functionality < by subclassing 
//   refactoring > solution > composition/delegation > combine behavior
//      also > bridge, chain of responsibility, composite, decorator,
//       observer, strategy
//+------------------------------------------------------------------+
//| applicability                                                    |
//+------------------------------------------------------------------+
//   represent > part-whole hierarchies of objects
//   clients > ignore > difference
//      compositions of objects and individual objects
//   clients > treat uniformly > composite structure objects
//+------------------------------------------------------------------+
//| structure                                                        |
//+------------------------------------------------------------------+
//
//     |Client|----->|    Component    |*<------------------+
//                   |-----------------|                    |
//                   |Operation()      |                    | 
//                   |Add(Component)   |                    |
//                   |Remove(Component)|                    |
//                   |GetChild(int)    |                    |
//                            ^                             |
//                            |                             |
//                    +-------+-----------+                 |
//                    |                   |           nodes |
//              |   Leaf    |   |     Composite     |o------+
//              |-----------|   |-------------------|
//              |Operation()|   |Operation()        |
//                              | for all n in nodes|
//                              |  n.Operation()    |
//                              |Add(Component)     |
//                              |Remove(Component)  |
//                              |GetChild(int)      |
//
//+------------------------------------------------------------------+
//| typical object structure                                         |
//+------------------------------------------------------------------+
//
//                        +---->|aLeaf|
//                        |
//       |aComposite|-----+---->|aLeaf|         +---->|aLeaf|
//                        |                     |
//                        +---->|aComposite|----+---->|aLeaf|
//                        |                     |
//                        +---->|aLeaf|         +---->|aLeaf|
//
#include <SRC\Patterns\PatternOrganizer.mqh>
namespace Composite
{
//+------------------------------------------------------------------+
//| participants                                                     |
//+------------------------------------------------------------------+
class Component
//   declares > interface 
//      objects < composition
//      accessing and managing child components
//   default behavior > interface > common to all classes
//   optional > interface
//      accessing > component's parent in the recursive structure
//      implements it if that's appropriate
  {
public:
   virtual void      Operation(void)=0;
   virtual void      Add(Component*)=0;
   virtual void      Remove(Component*)=0;
   virtual Component*   GetChild(int)=0;
                     Component(void);
                     Component(string);
protected:
   string            name;
  };
Component::Component(void) {}
Component::Component(string a_name):name(a_name) {}
//+------------------------------------------------------------------+
//| participants                                                     |
//+------------------------------------------------------------------+
#define ERR_INVALID_OPERATION_EXCEPTION   1
//user error for adding/removing a component to a leaf
class Leaf:public Component
//   represents > leaf objects < composition
//   no children
//   defines > behavior > primitive objects in the composition
  {
public:
   void              Operation(void);
   void              Add(Component*);
   void              Remove(Component*);
   Component*        GetChild(int);
                     Leaf(string);
  };
void Leaf::Leaf(string a_name):Component(a_name) {}
void Leaf::Operation(void) {Print(name);}
void Leaf::Add(Component*) {SetUserError(ERR_INVALID_OPERATION_EXCEPTION);}
void Leaf::Remove(Component*) {SetUserError(ERR_INVALID_OPERATION_EXCEPTION);}
Component* Leaf::GetChild(int) {SetUserError(ERR_INVALID_OPERATION_EXCEPTION); return NULL;}
//+------------------------------------------------------------------+
//| participants                                                     |
//+------------------------------------------------------------------+
class Composite:public Component
//   defines > behavior for components having children
//   stores > child components
//   implements > child-related operations > in component interface
  {
public:
   void              Operation(void);
   void              Add(Component*);
   void              Remove(Component*);
   Component*        GetChild(int);
                     Composite(string);
                    ~Composite(void);
protected:
   Component*        nodes[];
  };
Composite::Composite(string a_name):Component(a_name) {}
//+------------------------------------------------------------------+
//| participants > composite                                         |
//+------------------------------------------------------------------+
Composite::~Composite(void)
  {
   int total=ArraySize(nodes);
   for(int i=0; i<total; i++)
     {
      Component* i_node=nodes[i];
      if(CheckPointer(i_node)==1)
        {
         delete i_node;
        }
     }
  }
//+------------------------------------------------------------------+
//| participants > composite                                         |
//+------------------------------------------------------------------+
void Composite::Operation(void)
  {
   Print(name);
   int total=ArraySize(nodes);
   for(int i=0; i<total; i++)
     {
      nodes[i].Operation();
     }
  }
//+------------------------------------------------------------------+
//| participants > composite                                         |
//+------------------------------------------------------------------+
void Composite::Add(Component *src)
  {
   int size=ArraySize(nodes);
   ArrayResize(nodes,size+1);
   nodes[size]=src;
  }
//+------------------------------------------------------------------+
//| participants > composite                                         |
//+------------------------------------------------------------------+
void Composite::Remove(Component *src)
  {
   int find=-1;
   int total=ArraySize(nodes);
   for(int i=0; i<total; i++)
     {
      if(nodes[i]==src)
        {
         find=i;
         break;
        }
     }
   if(find>-1)
     {
      ArrayRemove(nodes,find,1);
     }
  }
//+------------------------------------------------------------------+
//| participants > composite                                         |
//+------------------------------------------------------------------+
Component* Composite::GetChild(int i)
  {
   return nodes[i];
  }
//+------------------------------------------------------------------+
//| participants                                                     |
//+------------------------------------------------------------------+
class Client:public ClientExample
//   manipulates objects in the composition through the component interface
  {
public:
   string            Output(void);
   void              Run(void);
  };
string Client::Output(void) {return __FUNCTION__;}
//+------------------------------------------------------------------+
//| collaborations                                                   |
//+------------------------------------------------------------------+
void Client::Run(void)
//   clients use the component class interface
//      to interact with objects in the composite structure
//   if the recipient is a leaf > the request is handled directly
//   if the recipient is a composite
//      it usually forwards requests to its child components
//      possibly performing additional operations
//       before and/or after forwarding
  {
   Component* root=new Composite("root"); //make root
//---make components
   Component* branch1=new Composite(" branch 1");
   Component* branch2=new Composite(" branch 2");
   Component* leaf1=new Leaf("  leaf 1");
   Component* leaf2=new Leaf("  leaf 2");
//---build tree
   root.Add(branch1);
   root.Add(branch2);
   branch1.Add(leaf1);
   branch1.Add(leaf2);
   branch2.Add(leaf2);
   branch2.Add(new Leaf("  leaf 3"));
//---check
   printf("tree:");
   root.Operation();
//---change tree
   root.Remove(branch1); //remove whole branch
//---check
   printf("tree after removal of one branch:");
   root.Operation();
//---finish
   delete root;
   delete branch1;
  }
}
//+------------------------------------------------------------------+
//| output                                                           |
//+------------------------------------------------------------------+
//   Structural::Composite::Client::Output
//   tree:
//   root
//    branch 1
//     leaf 1
//     leaf 2
//    branch 2
//     leaf 2
//     leaf 3
//   tree after removal of one branch:
//   root
//    branch 2
//     leaf 2
//     leaf 3
//+------------------------------------------------------------------+
//| consequences                                                     |
//+------------------------------------------------------------------+
//   defines class hierarchies consisting of primitive objects and composite objects
//   makes the client simple
//   makes it easier to add new kinds of components
//   can make your design overly general
//+------------------------------------------------------------------+
//| implementation                                                   |
//+------------------------------------------------------------------+
//   explicit parent references (in component)
//      simplify the traversal and management of a composite structure
//      help support the chain of responsibility pattern
//   sharing components
//      flyweight can rework a design to avoid storing parents altogether
//   maximizing the component interface
//      default implementations, leaf and composite will override them
//   declaring the child management operations
//      at the root of the class hierarchy > transparency
//      in the composite > afety
//      usually it's better to make add and remove fail by default
//         if the component isn't allowed to have children
//         or if the argument of remove isn't a child of the component
//   component may implement a list of components
//      if there are relatively few children in the structure
//   child ordering > design child access/management carefully > iterator
//   caching to improve performance
//      when components know their parents
//      tell composites that their caches are invalid
//   composite is responsible for deleting its children
//      when it's destroyed, unless leafs can be shared
//   composites store children in
//      linked lists, trees, arrays, and hash tables
//+------------------------------------------------------------------+
//| related patterns                                                 |
//+------------------------------------------------------------------+
//   chain of responsibility > component-parent link
//   decorator > common parent class > for decorators and composites
//   flyweight > share components (no longer refer to their parents)
//   iterator > traverse composites
//   visitor > localizes operations and behavior
//      distributed across composite and leaf classes
//+------------------------------------------------------------------+
    ATR Stop Loss ATR Stop Loss

    ATR Stop Loss indicator

    ATR adaptive SMA ATR adaptive SMA

    ATR adaptive SMA (simple moving average)

    Strategy - Set And Forget (with anti-Martingale system) Strategy - Set And Forget (with anti-Martingale system)

    This strategy is the well known set & forget accompanied by the anti-martingale system. It is very useful if you are very busy in which you don't have time, you want to trade the London session while you are sleeping in USA, etc.

    Peter Panel 1.0 Peter Panel 1.0

    Trading panel that allows user to define levels of trade by simply dragging lines.