//+------------------------------------------------------------------+
//|                                                     Strategy.mq5 |
//|                                    2019-2020, dimitri pecheritsa |
//|                                                 792112@gmail.com |
//+------------------------------------------------------------------+
//
//   strategy - behavioral design pattern
//
//   from: design patterns: elements of reusable object-oriented software
//   by gof: erich gamma, richard helm, ralph johnson, john vlissides
//   published in 1994
//
//   intent
//
//   define a family of algorithms, encapsulate each one, and make them
//interchangeable. strategy lets the algorithm vary independently from
//clients that use it
//
//   applicability
//
//   many related classes differ only in their behavior. strategies provide 
//a way to configure a class with one of many behaviors
//   you need different variants of an algorithm. for example, you might 
//define algorithms reflecting different space/time trade-offs. strategies 
//can be used when these variants are implemented as a class hierarchy 
//of algorithms
//   an algorithm uses data that clients shouldn't know about. use the 
//strategy pattern to avoid exposing complex, algorithm-specific data 
//structures
//   a class defines many behaviors, and these appear as multiple conditional 
//statements in its operations. instead of many conditionals, move related 
//conditional branches into their own strategy class
//
//   structure
//
//                        strategy
//   |     Context      |o-------->|      Strategy      |
//   |------------------|          |--------------------|
//   |ContextInterface()|          |AlgorithmInterface()|
//                                           ^
//                                           |
//                  +------------------------+----------------------+
//                  |                        |                      |
//        | ConcreteStrategyA  |  | ConcreteStrategyB  |  | ConcreteStrategyC  |
//        |--------------------|  |--------------------|  |--------------------|
//        |AlgorithmInterface()|  |AlgorithmInterface()|  |AlgorithmInterface()|
//
//
//   participants
//
//   strategy
//      declares an interface common to all supported algorithms. context 
//uses this interface to call the algorithm defined by a concrete strategy
//   concrete strategy
//      implements the algorithm using the strategy interface
//   context
//      is configured with a concrete strategy object
//      maintains a reference to a strategy object
//      may define an interface that lets strategy access its data
//
//   collaborations
//
//   strategy and context interact to implement the chosen algorithm. 
//a context may pass all data required by the algorithm to the strategy 
//when the algorithm is called. alternatively, the context can pass itself 
//as an argument to strategy operations. that lets the strategy call back 
//on the context as required
//   a context forwards requests from its clients to its strategy. clients 
//usually create and pass a concrete strategy object to the context; 
//thereafter, clients interact with the context exclusively. there is 
//often a family of concrete strategy classes for a client to choose from
//
//+------------------------------------------------------------------+
//|                                              example of a client |
//+------------------------------------------------------------------+
#include <Mqh\Patterns\Strategy\Strategy.mqh>
#include <Mqh\Patterns\Strategy\ConcreteStrategyA.mqh>
#include <Mqh\Patterns\Strategy\ConcreteStrategyB.mqh>
#include <Mqh\Patterns\Strategy\ConcreteStrategyC.mqh>
#include <Mqh\Patterns\Strategy\Context.mqh>
void OnStart()
  {
   Context* context;
//---strategy a
   context=new Context(new ConcreteStrategyA());
   context.ContextInterface();
   delete context;
//---strategy b
   context=new Context(new ConcreteStrategyB());
   context.ContextInterface();
   delete context;
//---strategy c
   context=new Context(new ConcreteStrategyC());
   context.ContextInterface();
   delete context;
  }
//
//   output
//
//   new strategy 2097152 loaded
//   requesting strategy algorithm
//   executing algorithm of strategy a (2097152)
//   new strategy 4194304 loaded
//   requesting strategy algorithm
//   executing algorithm of strategy b (4194304)
//   new strategy 6291456 loaded
//   requesting strategy algorithm
//   executing algorithm of strategy c (6291456)
//
//   consequences
//
//   families of related algorithms
//   an alternative to subclassing
//   strategies eliminate conditional statements
//   a choice of implementations
//   clients must be aware of different strategies
//   communication overhead between strategy and context
//   increased number of objects
//
//   implementation
//
//   defining the strategy and context interfaces
//   strategies as template parameters
//   making strategy objects optional
//
//   related patterns
//
//   strategy objects often make good flyweights
//
//+------------------------------------------------------------------+