How can you use the memento pattern for undo and redo?

1 Memento pattern overview

The memento pattern involves three roles: the originator, the caretaker, and the memento. The originator is the object whose state you want to save and restore. The caretaker is the object that manages the mementos and requests them from the originator. The memento is the object that stores the snapshot of the originator's state and provides a way to access it. The memento pattern decouples the originator from the caretaker, so that the originator does not need to know how the caretaker stores or uses the mementos. The memento pattern also encapsulates the originator's state, so that the caretaker cannot modify or access it directly.

2 Memento pattern implementation

To implement the memento pattern, you need to define the interface and the implementation of the originator, the caretaker, and the memento classes. The originator class should have methods to create and restore a memento, as well as other methods to perform its normal operations. The caretaker class should have methods to store and retrieve mementos in a data structure, such as a stack, a list, or a queue. The memento class should have methods to get and set the state of the originator, as well as a constructor that accepts the state as an argument. The memento class can be either public or private, depending on whether you want to expose its details to the caretaker or not.

3 Memento pattern example

Let's look at an example of how you can use the memento pattern for undo and redo in a simple text editor. The text editor has a text area where you can type and edit text, and two buttons for undo and redo. The text editor is the originator, the undo/redo manager is the caretaker, and the text snapshot is the memento. Here is some pseudocode to illustrate the idea:

// The originator class
class TextEditor {
  private String text; // The current text in the text area
  // The method to create a memento
  public TextSnapshot createSnapshot() {
    return new TextSnapshot(text);
  }
  // The method to restore a memento
  public void restoreSnapshot(TextSnapshot snapshot) {
    text = snapshot.getText();
  }
  // Other methods to edit and display text
}
// The memento class
class TextSnapshot {
  private String text; // The saved text
  // The constructor that accepts the text as an argument
  public TextSnapshot(String text) {
    this.text = text;
  }
  // The method to get the text
  public String getText() {
    return text;
  }
}
// The caretaker class
class UndoRedoManager {
  private Stack<TextSnapshot> undoStack; // The stack to store the undo mementos
  private Stack<TextSnapshot> redoStack; // The stack to store the redo mementos
  // The method to store a memento in the undo stack
  public void saveSnapshot(TextSnapshot snapshot) {
    undoStack.push(snapshot);
    redoStack.clear(); // Clear the redo stack when a new action is performed
  }
  // The method to retrieve a memento from the undo stack
  public TextSnapshot undo() {
    if (undoStack.isEmpty()) {
      return null; // No more undo actions available
    }
    TextSnapshot snapshot = undoStack.pop(); // Pop the top memento from the undo stack
    redoStack.push(snapshot); // Push the same memento to the redo stack
    return snapshot;
  }
  // The method to retrieve a memento from the redo stack
  public TextSnapshot redo() {
    if (redoStack.isEmpty()) {
      return null; // No more redo actions available
    }
    TextSnapshot snapshot = redoStack.pop(); // Pop the top memento from the redo stack
    undoStack.push(snapshot); // Push the same memento to the undo stack
    return snapshot;
  }
}        

4 Memento pattern benefits

The memento pattern has several benefits for implementing undo and redo functionality. First, it preserves the encapsulation of the originator, as it does not expose its internal state to the caretaker or other objects. Second, it simplifies the originator's logic, as it does not need to keep track of its previous states or how to revert them. Third, it gives the caretaker more control over the mementos, as it can decide when and how to store and retrieve them. Fourth, it makes the undo and redo operations reversible, as it can switch between the undo and redo stacks.

5 Memento pattern drawbacks

The memento pattern also has some drawbacks that you should be aware of. First, it can consume a lot of memory, as it creates and stores multiple mementos of the originator's state. Second, it can introduce performance overhead, as it copies and restores the state of the originator. Third, it can be difficult to implement for complex or interrelated objects, as it may require deep copying or coordination of multiple mementos. Fourth, it can be hard to test and debug, as it involves hidden state changes and interactions between the originator, the caretaker, and the memento.

6 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?