1. Memento Design Pattern
CECS277
Fall 2017
Mimi Opkins

2. Memento Design Pattern
Memento pattern is used to restore the state of an object to a previous state.
Memento pattern falls under the behavioral pattern category.

3. Implementation Memento pattern uses three actor classes.
Memento contains state of an object to be restored.
Originator creates and stores states in Memento objects and
Caretaker object is responsible to restore object state from Memento.

4. Intent
Capture and externalize an object’s state without violating encapsulation.
Restore the object’s state at some later time.
Useful when implementing checkpoints and undo mechanisms that let users back out of tentative operations or recover from errors.
Entrusts other objects with the information it needs to revert to a previous state without exposing its internal structure and representations.

5. Forces
Application needs to capture states at certain times or at user discretion. May be used for:
Undo / redo
Log errors or events
Backtracking
Need to preserve encapsulation
Don’t share knowledge of state with other objects
Object owning state may not know when to take state snapshot.

6. Memento Pattern – Motivation
Sometimes it's necessary to record the internal state of an object.
This is required when implementing checkpoints and undo mechanisms
Exposing this state would violate encapsulation
A memento is an object that stores a snapshot of the internal state of another object—the memento's originator.
The undo mechanism will request a memento from the originator when it needs to checkpoint the originator's state.
The originator initializes the memento with information that characterizes its current state.
Only the originator can store and retrieve information from the memento—the memento is "opaque" to other objects.

7. Motivation
Memento stores a snapshot of another object’s internal state, exposure of which would violate encapsulation and compromise the application’s reliability and extensibility.
A graphical editor may encapsulate the connectivity relationships between objects in a class, whose public interface might be insufficient to allow precise reversal of a move operation.
Move
Undo

8. Motivation Memento pattern solves this problem as follows:
The editor requests a memento from the object before executing move operation.
Originator creates and returns a memento.
During undo operation, the editor gives the memento back to the originator.
Based on the information in the memento, the originator restores itself to its previous state.

9. Applicability Use the Memento pattern when:
A snapshot of an object’s state must be saved so that it can be restored later, and
direct access to the state would expose implementation details and break encapsulation.

10. Participants
Memento
Stores internal state of the Originator object. Originator decides how much.
Protects against access by objects other than the originator.
Mementos have two interfaces:
Caretaker sees a narrow interface.
Originator sees a wide interface.

11. Participants (continued)
Originator
Creates a memento containing a snapshot of its current internal state.
Uses the memento to restore its internal state.

12. Caretaker Is responsible for the memento’s safekeeping.
Never operates on or examines the contents of a memento.

13. Collaborations
A caretaker requests a memento from an originator, holds it for a time, and passes it back to the originator.
Mementos are passive. Only the originator that created a memento will assign or retrieve its state.

14. Consequences Memento has several consequences:
Memento avoids exposing information that only an originator should manage, but for simplicity should be stored outside the originator.
Having clients manage the state they ask for simplifies the originator.

15. Consequences (continued)
Using mementos may be expensive, due to copying of large amounts of state or frequent creation of mementos.
A caretaker is responsible for deleting the mementos it cares for.
A caretaker may incur large storage costs when it stores mementos.

16. Implementation
When mementos get created and passed back to their originator in a predictable sequence, then Memento can save just incremental changes to originator’s state.

17. Memento Pattern - Structure
Intent
Without violating encapsulation, capture and externalize an object's internal state so that the object can be returned to this state later.
Structure

18. I/O streams, briefly
stream: an abstraction of a source or target of data
bytes "flow" to (output) and from (input) streams
can represent many data sources:
files on hard disk
another computer on network
web page
input device (keyboard, mouse, etc.)

19. Stream hierarchy
java.io.OutputStream ByteArrayOutputStream FileOutputStream ObjectOutputStream
java.io.InputStream
AudioInputStream
FileInputStream
ObjectInputStream

20. Serialization
serialization: reading / writing objects and their exact state using I/O streams
allows objects themselves to be written to files, across network, to internet, etc.
lets you save your objects to disk and restore later
avoids converting object's state into arbitrary text format

21. Classes used for serialization
in java.io package:
ObjectOutputStream class represents a connection to which an object can be written / sent (saved)
public class ObjectOutputStream
public ObjectOutputStream(OutputStream out)
public void writeObject(Object o) throws IOException
ObjectInputStream class represents a connection from which an object can be read / received (loaded)
public class ObjectInputStream
public ObjectInputStream(InputStream in)
public Object readObject() throws Exception
FileInputStream, FileOutputStream can be constructed from a file name String

22. Serialization example
recommendation: use a Memento class that has save/load code
// write the object named someObject to file "file.dat"
try {
OutputStream os = new FileOutputStream("file.dat");
ObjectOutputStream oos = new ObjectOutputStream(os);
oos.writeObject(someObject);
os.close();
} catch (IOException e) { ... }
// load the object named someObject from file "file.dat"
InputStream is = new FileInputStream("file.dat");
ObjectInputStream ois = new ObjectInputStream(is);
ArrayList someList = (ArrayList)ois.readObject();
is.close();
} catch (Exception e) { ... }

23. Making your classes serializable
must implement the (methodless) java.io.Serializable interface for your class to be compatible with object input/output streams
public class BankAccount implements Serializable {
...
ensure that all instance variables inside your class are either serializable or declared transient
transient fields won't be saved when object is serialized

24. Memento Pattern – Example
public class Originator {
private int number; private File file = null;
public Originator(){}
public Memento getMemento() { return new Memento(this);}
public void setMemento(Memento m){number = m.number; file = m.file;} }
private class Memento implements java.io.Serializable{
private int number;
private File file = null;
public Memento( Originator o){ number = o.number; file = o.file;} }

25. Memento Pattern – Example
https//sourcemaking.com/design_patterns/memento/java/1

26. Credits TCSS 360, Spring 2005 Lecture Notes Jim Fawcett
CSE776 – Design Patterns
Summer 2005
Chap 6 - Design Patterns