Memento

The Memento design pattern is a behavioral design pattern that allows an object to save its state so that it can be restored later. This is useful for implementing features like undo/redo operations.

Imagine you have an object that you want to save the state of at a certain point in time. You can create a Memento object that stores the state of the object. Later, you can restore the object to that state using the Memento.

Common use cases

• Undo/Redo Mechanisms:

  • Applications like text editors, drawing applications, and IDEs often implement undo and redo functionality using the Memento pattern. Each change in the application’s state is saved as a Memento, allowing users to revert to previous states.

• State Persistence:

  • Games often use the Memento pattern to save the state of a game at certain checkpoints. This allows players to resume the game from a saved state.

• Transactional Systems:

  • In database systems or other transactional systems, the Memento pattern can be used to save the state before a transaction. If the transaction fails, the system can revert to the previous state.

• Configuration Management:

  • Software that allows users to change settings or configurations can use the Memento pattern to save the current configuration. Users can then revert to a previous configuration if needed.

• State History Tracking:

  • Applications that need to keep a history of states, such as version control systems, can use the Memento pattern to store snapshots of the state at different points in time.

• Prototype-based Object Creation:

  • In scenarios where objects are created based on a prototype, the Memento pattern can be used to save the state of the prototype object, allowing new objects to be created with the same state.

These use cases leverage the Memento pattern’s ability to capture and restore an object’s state without violating encapsulation.

Key Components

• Originator: The object whose state needs to be saved and restored.

• Memento: The object that stores the state of the Originator.

• Caretaker: The object that keeps track of multiple Mementos. It does not modify or inspect the contents of the Memento.

--- Python Example ---

 class Originator:
     def __init__(self, state):
         self._state = state

     def save_state(self):
         return Memento(self._state)

     def restore_state(self, memento):
         self._state = memento.get_state()

     def set_state(self, state):
         self._state = state

     def get_state(self):
         return self._state

 class Memento:
     def __init__(self, state):
         self._state = state

     def get_state(self):
         return self._state

 class Caretaker:
     def __init__(self):
         self._mementos = []

     def add_memento(self, memento):
         self._mementos.append(memento)

     def get_memento(self, index):
         return self._mementos[index]

 if __name__ == "__main__":
     # Create an originator with an initial state
     originator = Originator("State1")
     caretaker = Caretaker()

     # Save the state
     caretaker.add_memento(originator.save_state())

     # Change the state
     originator.set_state("State2")

     # Restore the state
     originator.restore_state(caretaker.get_memento(0))
     print(originator.get_state())  # Output: State1

--- Java Example ---

 public class Originator {
     private String state;

     public void setState(String state) {
         this.state = state;
     }

     public String getState() {
         return state;
     }

     public Memento saveStateToMemento() {
         return new Memento(state);
     }

     public void getStateFromMemento(Memento memento) {
         state = memento.getState();
     }
 }

 // Memento
 public class Memento {
     private final String state;

     public Memento(String state) {
         this.state = state;
     }

     public String getState() {
         return state;
     }
 }

 // Caretaker
 public class Caretaker {
     private final List<Memento> mementoList = new ArrayList<>();

     public void add(Memento state) {
         mementoList.add(state);
     }

     public Memento get(int index) {
         return mementoList.get(index);
     }
 }

 // Main
 public class Main {
     public static void main(String[] args) {
         Originator originator = new Originator();
         Caretaker caretaker = new Caretaker();

         originator.setState("State1");
         caretaker.add(originator.saveStateToMemento());

         originator.setState("State2");

         originator.getStateFromMemento(caretaker.get(0));
         System.out.println("Current State: " + originator.getState());  // Output: State1
     }
 }

In these examples, the Originator can save its state to a Memento and restore it later. The Caretaker manages the saved states without modifying them.