//+------------------------------------------------------------------+
//| 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
//+------------------------------------------------------------------+
#30884LibrariesMetaTrader 5👁 3942 views
Composite - structural design pattern
D
Author
DMITRII PECHERITSAPublished date
Sep 2, 2020
📚Related Articles
← View other articles →#77531Libraries
CSetupLedger: a per-setup win rate ledger for Expert Advisors
Why I wrote it My scalper trades two setups. A bullish order block and the bearish mirror of it. The Strategy Tester gave me one profit factor for both of them. I spent two weeks t...
Ali AkbarView detail →
#77488Libraries
Position sizing from risk, using the broker's own tick value and volume step
Every lot size calculator that assumes one pip is worth ten dollars is wrong on gold, wrong on indices, wrong on JPY crosses and wrong on any account not denominated in USD which i...
Ralph Ivan SimeonView detail →
#77156Libraries
PropFirm Defense
A prop firm account runs under a second rulebook MetaTrader 5 knows nothing about: a maximum loss measured from a fixed starting balance, a daily limit that resets at an hour the b...
Bruno Nunes Myrrha RibeiroView detail →