//+------------------------------------------------------------------+
//| 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
//+------------------------------------------------------------------+
Comments