Memento pattern.

- Caretaker should save history for normal pattern implementation.
- Importent notes in code of Originator.
- Readme with full pattern philosophy.
- Tests and example of usage inside test.

Behavioral/Memento/README.rst

@@ -4,26 +4,43 @@
 Purpose
 -------
 
-Provide the ability to restore an object to its previous state (undo via
-rollback).
+It provides the ability to restore an object to its previous state (undo
+via rollback) or to gain access to state of the object, without revealing
+its implementation (ie, the object is not required to have a functional
+for return the current state).
 
-The memento pattern is implemented with three objects: the originator, a
-caretaker and a memento. The originator is some object that has an
-internal state. The caretaker is going to do something to the
-originator, but wants to be able to undo the change. The caretaker first
-asks the originator for a memento object. Then it does whatever
-operation (or sequence of operations) it was going to do. To roll back
-to the state before the operations, it returns the memento object to the
-originator. The memento object itself is an opaque object (one which the
-caretaker cannot, or should not, change). When using this pattern, care
-should be taken if the originator may change other objects or resources
-- the memento pattern operates on a single object.
+The memento pattern is implemented with three objects: the Originator, a
+Caretaker and a Memento.
+
+Memento – an object that *contains a concrete unique snapshot of state* of
+any object or resource: string, number, array, an instance of class and so on.
+The uniqueness in this case  not imply the prohibition existence of similar
+states in different snapshots. That means the state can be extracted as
+the independent clone. Any object stored in the Memento should be
+*a full copy of the original object rather than a reference* to the original
+object. The Memento object is a "opaque object" (the object that no one can
+or should change).
+
+Originator – it is an object that contains the *actual state of an external
+object is strictly specified type*. Originator is able to create a unique
+copy of this state and return it wrapped in a Memento. The Originator does
+not know the history of changes. You can set a concrete state to Originator
+from the outside, which will be considered as actual. The Originator must
+make sure that given state corresponds the allowed type of object. Originator
+may (but not should) have any methods, but they *they can't make changes to
+the saved object state*.
+
+Caretaker *controls the states history*. He may make changes to an object;
+take a decision to save the state of an external object in the Originator;
+ask from the Originator snapshot of the current state; or set the Originator
+state to equivalence with some snapshot from history.
 
 Examples
 --------
 
 -  The seed of a pseudorandom number generator
 -  The state in a finite state machine
+-  Control for intermediate states of `ORM Model <http://en.wikipedia.org/wiki/Object-relational_mapping>`_ before saving
 
 UML Diagram
 -----------