//+------------------------------------------------------------------+ //| 201104_114239.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 //+------------------------------------------------------------------+ //| memento - behavioral design pattern | //+------------------------------------------------------------------+ // without violating encapsulation, capture and externalize an object's //internal state so that the object can be restored to this state later //+------------------------------------------------------------------+ //| applicability | //+------------------------------------------------------------------+ // a snapshot of (some portion of) an object's state must be saved so //that it can be restored to that state later, and // a direct interface to obtaining the state would expose implementation //details and break the object's encapsulation //+------------------------------------------------------------------+ //| structure | //+------------------------------------------------------------------+ // memento // | Originator |- - ->| Memento |<-------o|Caretaker| // |--------------------------| |----------| // |SetMemento(Memento m) | |GetState()| // | state=m.GetState() | |SetState()| // |CreateMemento() | |----------| // | return new Memento(state)| |state | // |--------------------------| // |state | // //+------------------------------------------------------------------+ //| participants | //+------------------------------------------------------------------+ // memento // stores internal state of the originator object. the memento may //store as much or as little of the originator's internal state as necessary //at its originator's discretion // protects against access by objects other than the originator. //mementos have effectively two interfaces. caretaker sees a narrow interface //to the memento — it can only pass the memento to other objects. originator, //in contrast, sees a wide interface, one that lets it access all the data //necessary to restore itself to its previous state. ideally, only the //originator that produced the memento would be permitted to access the //memento's internal state // originator // creates a memento containing a snapshot of its current internal state // uses the memento to restore its internal state // caretaker // is responsible for the memento's safekeeping // never operates on or examines the contents of a memento //+------------------------------------------------------------------+ //| collaborations | //+------------------------------------------------------------------+ #include <Mqh\201104_114823.mqh> //memento #include <Mqh\201104_115143.mqh> //originator #include <Mqh\201104_115621.mqh> //caretaker // a caretaker requests a memento from an originator, holds it for a //time, and passes it back to the originator: // // aCaretaker anOriginator aMemento // | | | // | |CreateMemento() | // | |--------------------->| |new Memento | // | | | |- - - - - - - - - - ->| | // | | | |SetState() | // | | | |--------------------->| | // | | | // / / / // / / / // | | | // | |SetMemento() | | // | |--------------------->| |GetState() | // | | | |--------------------->| | // | | | // // sometimes the caretaker won't pass the memento back to the originator, //because the originator might never need to revert to an earlier state // mementos are passive. only the originator that created a memento will //assign or retrieve its state //--- void OnStart() { Originator originator; Caretaker caretaker; //--- originator.State("on"); caretaker.memento=originator.CreateMemento(); originator.State("off"); originator.SetMemento(caretaker.memento); } //+------------------------------------------------------------------+ //| output | //+------------------------------------------------------------------+ // changing originator state to on // creating memento with current state on // changing originator state to off // restoring originator state from memento to on //+------------------------------------------------------------------+ //| consequences | //+------------------------------------------------------------------+ // preserving encapsulation boundaries // it simplifies originator // using mementos might be expensive // defining narrow and wide interfaces // hidden costs in caring for mementos //+------------------------------------------------------------------+ //| implementation | //+------------------------------------------------------------------+ // language support // storing incremental changes //+------------------------------------------------------------------+ //| related patterns | //+------------------------------------------------------------------+ // command: commands can use mementos to maintain state for undoable operations // iterator: mementos can be used for iteration as described earlier //+------------------------------------------------------------------+
