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

All creational design patterns - library for MetaTrader 5

DMITRII PECHERITSA

Views:
801
Rating:
votes: 7
Published:
2020.08.12 10:35
Updated:
2020.08.31 07:09
Pattern.mq5 (7.04 KB)view
\MQL5\Include\SRC\Patterns\\MQL5\Include\SRC\Patterns\Creational\
Builder.mqh (14.65 KB)view
Prototype.mqh (22.08 KB)view
//+------------------------------------------------------------------+
//|                                             PatternOrganizer.mqh |
//|                                    2019-2020, dimitri pecheritsa |
//|                                                 792112@gmail.com |
//+------------------------------------------------------------------+
//| 23 design patterns                                               |
//+------------------------------------------------------------------+
//   design patterns: elements of reusable object-oriented software
//   gof > erich gamma, richard helm, ralph johnson, john vlissides 
//   published in 1994
//+------------------------------------------------------------------+
//| classification                                                   |
//+------------------------------------------------------------------+
//   purpose > creational > 5
//      abstract factory, builder, factory method, prototype, singleton
//   purpose > structural > 7
//      adapter, bridge, composite, decorator, facade, flyweight, proxy
//   purpose > behavioral > 11
//      chain of responsibility, command, interpreter, iterator, mediator
//      memento, observer, state, strategy, template method, visitor
//   scope > class > 3 > factory method, interpreter, template method
//   scope > object > 20 > all other
//+------------------------------------------------------------------+
//| relationships                                                    |
//+------------------------------------------------------------------+
//
//                       +-------------->|memento|      |proxy|
//                       |                   ^           |adapter|
//                  saving state             |            |bridge |
//                  of iteration          avoiding
//                       |               hysteresis
//    |builder|      |iterator|<---+         |        |   chain of   |
//        ^              ^         |     |command|    |responsibility|
//        |              |         |         |               |
//     creating     enumerating    |      composed        defining
//    composites      children     |       using         the chain
//        |              |         |         |               |
//        +---------|composite|<---|---------+---------------+
//        |              |         |                         |
//     adding            |     defining------------+      defining
// responsibilities      |    traversals           |      grammar
//   to objects          |                         |         |
//        |              +--------adding------>|visitor|     |
//        v              |      operations                   |
//   |decorator|      sharing       |                        |
//        ^          composites     +--------|interpreter|---+
//        |              |                         |
//        |              v             sharing     |
//  changing skin     |flyweight|<-----terminal----+
//    vs. guts               ^         symbols          |observer|
//        |       sharing    |                              |
//        |     strategies---+---sharing                    |
//        v          |           states                  complex
//   |strategy|------+             |     |mediator|<----dependency
//        ^                     |state|                 management
//        |
//     sharing
//   algorithm's----------|template method|----often uses---+
//      steps                                               |
//                                                          |
//   |prototype|<--+                                        |
//                 |                                        v
//         configure factory          implement---->|factory method|
//            dynamically               using
//                 |                      |
//         |abstract factory|---+---------+
//                              |
//                           single
//   |singleton|<-----------instance------------|facade|
//
//+------------------------------------------------------------------+
//| code refactoring                                                 |
//+------------------------------------------------------------------+
//   create objects < explicitly > create indirectly
//      abstract factory, factory method, prototype
//   dependence > specific operations > avoid > hard-coded requests
//      chain of responsibility, command
//   dependence > hardware and software > limit 
//      abstract factory, bridge
//   dependence > object representations/implementations
//      hide from clients > keep changes from cascading
//      abstract factory, bridge, memento, proxy
//   algorithmic dependencies > isolate > algorithms that may change
//      builder, iterator, strategy, template method, visitor
//   tight coupling > decouple < abstract coupling and layering
//      abstract factory, bridge, chain of responsibility,
//      command, facade, mediator, observer
//   extending functionality < subclassing 
//      composition/delegation > combine behavior
//      bridge, chain of responsibility, composite, decorator,
//      observer, strategy
//   inability to alter classes conveniently > adapter, decorator, visitor
//+------------------------------------------------------------------+
//| creational > abstract factory                                    |
//+------------------------------------------------------------------+
//   interface > families of related/dependent objects
//    without specifying concrete classes
//   variable aspect > families of product objects
//
//            | AbstractFactory|<-----------------------------------------|Client|
//            |----------------|                                              |
//            |CreateProductA()|                                              |
//            |CreateProductA()|                    |AbstractProductA|<-------+
//                     ^                                    ^                 |
//                     |                                    |                 |
//         +-----------+----------+                   +-----+-----+           |
//         |                      |                   |           |           |
//|ConcreteFactory1|- +  |ConcreteFactory2|- + ->|ProductA2| |ProductA1|<- +  |
//|----------------|  |  |----------------|  |                             |  |
//|CreateProductA()|     |CreateProductA()|                                   |
//|CreateProductB()|  |  |CreateProductB()|  |                             |  |
//                                                  |AbstractProductB|<----+--+
//                    |                      |              ^              |
//                                                          |
//                    |                      |        +-----+-----+        |
//                                                    |           |
//                    |                      + ->|ProductB2| |ProductB1|<- +
//                                                                         |
//                    +  - - - - - - - - - - - - - - - - - - - - - - - - - +
//
//+------------------------------------------------------------------+
//| creational > builder                                             |
//+------------------------------------------------------------------+
//   for a complex object > separate construction from representation
//   same construction process can create different representations
//   variable aspect > the way a composite object gets created
//
//                                  builder
//  |           Director          |o--------->|  Builder  |
//  |-----------------------------|           |-----------|
//  |Construct()                  |           |BuildPart()|
//  | for all objects in structure|                 ^
//  |  builder.BuildPart()        |                 |
//                                          |ConcreteBuilder|- - ->|Product|
//                                          |---------------|
//                                          |BuildPart()    |
//                                          |GetResult()    |
//
//+------------------------------------------------------------------+
//| creational > factory method                                      |
//+------------------------------------------------------------------+
//   interface for creating an object > defers instantiation to subclasses
//   subclasses decide which class to instantiate
//   variable aspect > subclass of object that is instantiated
//
//                                 |         Creator        |
//                                 |------------------------|
//                                 |FactoryMethod()         |
//                                 |AnOperation()           |
//                                 | ...                    |
//                                 | product=FactoryMethod()|
//        |Product|                | ...                    |
//            ^                                ^
//            |                                |
//    |ConcreteProduct|<- - - - -|      ConcreteCreator      |
//                               |---------------------------|
//                               |FactoryMethod()            |
//                               | return new ConcreteProduct|
//
//+------------------------------------------------------------------+
//| creational > prototype                                           |
//+------------------------------------------------------------------+
//   create objects > by copying a prototype
//   variable aspect > class of object that is instantiated
//
//                         prototype
//  |       Client       |------------>|Prototype|
//  |--------------------|             |---------|
//  |Operation()         |             |Clone()  |
//  | p=prototype.Clone()|                  ^
//                                          |
//                              +-----------+------------+
//                              |                        |
//                   | ConcretePrototype1 |   | ConcretePrototype2 |
//                   |--------------------|   |--------------------|
//                   |Clone()             |   |Clone()             |
//                   | return copy of self|   | return copy of self|
//
//+------------------------------------------------------------------+
//| creational > singleton                                           |
//+------------------------------------------------------------------+
//   ensure > one instance of a class with a global point of access
//   variable aspect > the sole instance of a class
//
//                       |       Singleton      |
//                       |----------------------|
//                       |static Instance()     |
//                       | return uniqueInstance|
//                       |SingletonOperation()  |
//                       |GetSingletonData()    |
//                       |----------------------|
//                       |static uniqueInstance |
//                       |singletonData         |
//
//+------------------------------------------------------------------+
//| interface for patterns                                           |
//+------------------------------------------------------------------+
interface ClientExample //pattern client
  {
   string Output(void); //returns header
   void Run(void); //execute the pattern client
  };
//+------------------------------------------------------------------+
//| interface for patterns                                           |
//+------------------------------------------------------------------+
void Run(ClientExample* client) //launches a pattern
  {
   printf("---\n%s",client.Output()); //print pattern header
   client.Run(); //execute client collaborations
   delete client; //exit
  }
//+------------------------------------------------------------------+
//| include > patterns                                               |
//+------------------------------------------------------------------+
namespace Creational
{
#include "Creational\AbstractFactory.mqh"
#include "Creational\Builder.mqh"
#include "Creational\FactoryMethod.mqh"
#include "Creational\Prototype.mqh"
#include "Creational\Singleton.mqh"
}
//+------------------------------------------------------------------+



//+------------------------------------------------------------------+
//|                                                      Pattern.mq5 |
//|                                    2019-2020, dimitri pecheritsa |
//|                                                 792112@gmail.com |
//+------------------------------------------------------------------+
#include <SRC\Patterns\PatternOrganizer.mqh>
//+------------------------------------------------------------------+
//| run                                                              |
//+------------------------------------------------------------------+
void OnStart() //launch pattern clients one by one and check result
  {
//---creational
   Run(new Creational::AbstractFactory::Client);
   Run(new Creational::Builder::Client);
   Run(new Creational::FactoryMethod::Client);
   Run(new Creational::Prototype::Client);
   Run(new Creational::Singleton::Client);
  }
//+------------------------------------------------------------------+
//| output > abstract factory                                        |
//+------------------------------------------------------------------+
//   Creational::AbstractFactory::Client::Output
//   client is requesting to create factory 1
//   client is requesting to create the factory client
//   client is requesting the factory client to manage factory 1
//   factory 1: 3145728 constructed
//   factory client created and received abstract factory 3145728
//   factory client is requesting to accept/switch the factories
//   factory client is accepting new factory 3145728
//   factory client saved the new factory
//   factory client is requesting its new factory to create product a
//   factory 1 is creating and returning product a1
//   product a1 constructed
//   factory client is requesting its new factory to create product b
//   factory 1 is creating and returning product b1
//   product b1 constructed
//   client is requesting the factory client to operate
//   factory client is running abstract product b
//   product b1: 5242880 is interacting with product a: 4194304
//   client is requesting to create new factory 2 and asking factory client to switch factories
//   factory 2: 6291456 constructed
//   factory client is switching old factory 3145728 to new factory 6291456
//   factory client saved the new factory
//   factory client is requesting its new factory to create product a
//   factory 2 is creating and returning product a2
//   product a2 constructed
//   factory client is requesting its new factory to create product b
//   factory 2 is creating and returning product b2
//   product b2 constructed
//   client is requesting the factory client to run again
//   factory client is running abstract product b
//   product b2: 8388608 is interacting with product a: 7340032
//+------------------------------------------------------------------+
//| output > builder                                                 |
//+------------------------------------------------------------------+
//   Creational::Builder::Client::Output
//   client is requesting to create a new concrete builder
//   client is requesting to create a director and give him the builder
//   director created and received builder 10485760
//   client is requesting the director to perform the construction
//   director has started the construction
//   director is requesting its builder to build the product parts
//   builder is requesting the product to add part a to itself
//   product added part a to itself
//   builder has made part a and added it to the product
//   builder is requesting the product to add part b to itself
//   product added part b to itself
//   builder has made part b and added it to the product
//   builder is requesting the product to add part c to itself
//   product added part c to itself
//   builder has made part c and added it to the product
//   director's builder constructed the product from parts
//   client is requesting the builder to return the result product
//   builder is returning the product
//   client is requesting the product the describe itself
//   product is showing all parts that it is made of
//   part a
//   part b
//   part c
//+------------------------------------------------------------------+
//| output > factory method                                          |
//+------------------------------------------------------------------+
//   Creational::FactoryMethod::Client::Output
//   requesting to make a creator
//   requesting creator to run its factory method to return the product
//   creator is running a factory method
//   concrete creator is creating and returning new concrete product
//   concrete product: 15728640 created
//   requesting creator to run its operation
//   creator is running its operation
//   creator is running a factory method
//   concrete creator is creating and returning new concrete product
//   concrete product: 16777216 created
//   creator has saved the product received from a virtual factory method
//+------------------------------------------------------------------+
//| output > prototype                                               |
//+------------------------------------------------------------------+
//   Creational::Prototype::Client::Output
//   requesting to create a concrete prototype 1 with id 1
//   prototype 18874368, id: 1 created
//   concrete prototype 1: 18874368, id: 1 created
//   requesting prototype 18874368 to create its clone
//   cloning concrete prototype 1: 18874368, id: 1
//   prototype 19922944, id: 1 created
//   concrete prototype 1: 19922944, id: 1 created
//   requesting to create a concrete prototype 2 with id 2
//   prototype 20971520, id: 2 created
//   concrete prototype 2: 20971520, id: 2 created
//   requesting prototype 20971520 to create its clone
//   cloning concrete prototype 2: 20971520, id: 2
//   prototype 22020096, id: 2 created
//   concrete prototype 2: 22020096, id: 2 created
//+------------------------------------------------------------------+
//| output > singleton                                               |
//+------------------------------------------------------------------+
//   Creational::Singleton::Client::Output
//   requesting singleton instance 1
//   singleton instance method is running
//   unique instance of the singleton is empty
//   singleton 24117248 created
//   singleton assigned to unique instance
//   unique instance contains singleton: 24117248
//   returning the unique instance 24117248 of the singleton
//   requesting singleton instance 2
//   singleton instance method is running
//   unique instance contains singleton: 24117248
//   returning the unique instance 24117248 of the singleton
//   instances 1 and instance 2 are same objects
//   requesting singleton operation on instance 1
//   running singleton operation > setting singleton data
//   requesting singleton data via singleton instance 2
//   reading and returning singleton data
//   singleton data
//+------------------------------------------------------------------+


Singleton - creational design pattern Singleton - creational design pattern

Ensure one instance of a class with a global point of access

Periodic Range Breakout (Martingale) Periodic Range Breakout (Martingale)

Trend Follower Range Breakout System with Martingale.

VR Watch List and Linker Lite MT5 VR Watch List and Linker Lite MT5

Synchronous change of a trading instrument in all charts

Adapter - structural design pattern Adapter - structural design pattern

Convert the interface of a class into another expected interface; classes with incompatible interfaces can work together