201104_114239

ÿþ//+------------------------------------------------------------------+

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

//+------------------------------------------------------------------+