//+------------------------------------------------------------------+  //|                                                201021_113117.mq5 |  //|                                    2019-2020, dimitri pecheritsa |  //|                                                 792112@gmail.com |  //+------------------------------------------------------------------+  //   from: design patterns: elements of reusable object-oriented software  //   by: gof: erich gamma, richard helm, ralph johnson, john vlissides  //   published in 1994  //+------------------------------------------------------------------+  //| iterator - behavioral design pattern                             |  //+------------------------------------------------------------------+  //   provide a way to access the elements of an aggregate object  // sequentially without exposing its underlying representation  //+------------------------------------------------------------------+  //| applicability                                                    |  //+------------------------------------------------------------------+  //   access an aggregate object's contents without exposing its  // internal representation  //   support multiple traversals of aggregate objects  //   provide a uniform interface for traversing different aggregate  // structures (that is, to support polymorphic iteration)  //+------------------------------------------------------------------+  //| structure                                                        |  //+------------------------------------------------------------------+  //  //         |    Aggregate   |<------|Client|------->|   Iterator  |  //         |----------------|                       |-------------|  //         |CreateIterator()|                       |First()      |  //                 ^                                |Next()       |  //                 |                                |IsDone()     |  //                 |                                |CurrentItem()|  //                 |                                       ^  //                 |                                       |  //|             Concrete             |- - - - - - - ->|Concrete|  //|            Aggregate             |<---------------|Iterator|  //|----------------------------------|  //|CreateIterator()                  |  //| return new ConcreteIterator(this)|  //  //+------------------------------------------------------------------+  //| participants                                                     |  //+------------------------------------------------------------------+  //   iterator  //      defines an interface for accessing and traversing elements  //   aggregate  //      defines an interface for creating an iterator object  //   concrete iterator  //      implements the iterator interface  //      keeps track of the current position in the traversal of the  // aggregate  //   concrete aggregate  //      implements the iterator creation interface to return an  // instance of the proper concrete iterator  //+------------------------------------------------------------------+  //| collaborations                                                   |  //+------------------------------------------------------------------+  //   a concrete iterator keeps track of the current object in the  // aggregate and can compute the succeeding object in the traversal                                       |  //---iterator participants  #include <Mqh\201021_104101.mqh> //iterator  #include <Mqh\201021_104329.mqh> //aggregate  #include <Mqh\201021_104505.mqh> //concrete iterator  #include <Mqh\201021_104755.mqh> //concrete aggregate  //---  void OnStart()    {     Aggregate<string>* aggregate=new ConcreteAggregate;     aggregate+="element a";     aggregate+="element b";     aggregate+="element c";     aggregate+="element d";  //---     Iterator<string>* iterator=aggregate.CreateIterator();     for(iterator.First(); !iterator.IsDone(); iterator.Next())       {        Print(iterator.CurrentItem());       }  //---     delete aggregate;     delete iterator;    }  //+------------------------------------------------------------------+  //| output                                                           |  //+------------------------------------------------------------------+  //   first iteration of aggregate   //   element a  //   next iteration of aggregate   //   element b  //   next iteration of aggregate   //   element c  //   next iteration of aggregate   //   element d  //+------------------------------------------------------------------+  //| consequences                                                     |  //+------------------------------------------------------------------+  //   it supports variations in the traversal of an aggregate  //      to change  the traversal algorithm just replace the iterator   // instance with a different one  //      you can also define iterator subclasses to support new traversals  //   iterators simplify the aggregate interface  //   more than one traversal can be pending on an aggregate  //+------------------------------------------------------------------+  //| implementation                                                   |  //+------------------------------------------------------------------+  //   who controls the iteration?   //   who defines the traversal algorithm?   //   how robust is the iterator?   //   additional iterator operations  //   using polymorphic iterators in c++  //   iterators may have privileged access  //   iterators for composites  //   null iterators  //+------------------------------------------------------------------+