Memento Design Pattern in PHP: Capturing and Restoring Object State

7.6 Memento Pattern

The Memento Pattern is a behavioral design pattern that provides the ability to restore an object to its previous state. This pattern is particularly useful for implementing features like undo mechanisms, checkpoints in games, or any scenario where you need to revert an object to a previous state without exposing its internal structure.

Intent

The primary intent of the Memento Pattern is to capture and externalize an object’s internal state without violating encapsulation, allowing it to be restored later. This is achieved by storing the state in a separate object, known as the memento, which can be used to restore the original object to its previous state.

Key Participants

1. Originator: The object whose state needs to be saved and restored. It creates a memento containing a snapshot of its current state and can use the memento to restore its state.
2. Memento: The object that stores the internal state of the originator. It is opaque to other objects and is only used by the originator.
3. Caretaker: Manages the mementos and is responsible for storing and restoring them. It does not modify or inspect the contents of the memento.

Applicability

Use the Memento Pattern when:

• You need to implement an undo mechanism.
• You want to save and restore the state of an object without exposing its internal structure.
• You need to maintain checkpoints in applications like games or simulations.

Implementing Memento in PHP

Let’s explore how to implement the Memento Pattern in PHP by creating a simple text editor application that supports undo functionality.

Step 1: Define the Originator

The TextEditor class acts as the originator. It maintains the current text and can create and restore mementos.

 1<?php
 2
 3class TextEditor {
 4    private $text = '';
 5
 6    public function write($words) {
 7        $this->text .= $words;
 8    }
 9
10    public function getText() {
11        return $this->text;
12    }
13
14    public function save() {
15        return new TextEditorMemento($this->text);
16    }
17
18    public function restore(TextEditorMemento $memento) {
19        $this->text = $memento->getText();
20    }
21}

Step 2: Create the Memento

The TextEditorMemento class stores the state of the TextEditor.

 1<?php
 2
 3class TextEditorMemento {
 4    private $text;
 5
 6    public function __construct($text) {
 7        $this->text = $text;
 8    }
 9
10    public function getText() {
11        return $this->text;
12    }
13}

Step 3: Implement the Caretaker

The EditorHistory class acts as the caretaker, managing the mementos.

 1<?php
 2
 3class EditorHistory {
 4    private $history = [];
 5
 6    public function save(TextEditorMemento $memento) {
 7        $this->history[] = $memento;
 8    }
 9
10    public function undo() {
11        if (!empty($this->history)) {
12            return array_pop($this->history);
13        }
14        return null;
15    }
16}

Step 4: Demonstrate the Memento Pattern

Let’s see how these classes work together to provide undo functionality.

 1<?php
 2
 3$editor = new TextEditor();
 4$history = new EditorHistory();
 5
 6$editor->write("Hello, ");
 7$history->save($editor->save());
 8
 9$editor->write("World!");
10$history->save($editor->save());
11
12echo "Current Text: " . $editor->getText() . "\n"; // Output: Hello, World!
13
14$editor->restore($history->undo());
15echo "After Undo: " . $editor->getText() . "\n"; // Output: Hello, 
16
17$editor->restore($history->undo());
18echo "After Undo: " . $editor->getText() . "\n"; // Output: (empty string)

Visualizing the Memento Pattern

To better understand the interactions between the components of the Memento Pattern, let’s visualize it using a class diagram.

    classDiagram
	    class TextEditor {
	        - text: string
	        + write(words: string)
	        + getText(): string
	        + save(): TextEditorMemento
	        + restore(memento: TextEditorMemento)
	    }
	
	    class TextEditorMemento {
	        - text: string
	        + getText(): string
	    }
	
	    class EditorHistory {
	        - history: array
	        + save(memento: TextEditorMemento)
	        + undo(): TextEditorMemento
	    }
	
	    TextEditor --> TextEditorMemento
	    EditorHistory --> TextEditorMemento

Design Considerations

• Encapsulation: The Memento Pattern maintains encapsulation by keeping the memento’s state private and only accessible to the originator.
• Memory Usage: Be cautious of memory usage when storing large states or a large number of mementos.
• Complexity: The pattern can add complexity to your codebase, so use it judiciously.

PHP Unique Features

PHP’s object-oriented capabilities make it well-suited for implementing the Memento Pattern. The use of classes and encapsulation aligns with the pattern’s requirements. PHP’s dynamic typing allows for flexible handling of different types of state data.

Differences and Similarities

The Memento Pattern is often confused with the Command Pattern, as both can be used to implement undo functionality. However, the Command Pattern encapsulates actions, while the Memento Pattern encapsulates state.

Use Cases and Examples

1. Undo Mechanisms: Implementing undo functionality in applications like text editors, drawing applications, or any software that requires state rollback.
2. Checkpoints in Games: Saving game states at checkpoints to allow players to revert to a previous point in the game.
3. State History: Maintaining a history of changes in applications like document editors or version control systems.

Try It Yourself

Experiment with the code examples by modifying the TextEditor class to include additional features, such as:

• Adding a redo functionality.
• Storing additional state information, like cursor position.
• Implementing a limit on the number of mementos stored to manage memory usage.

Knowledge Check

• What is the primary intent of the Memento Pattern?
• How does the Memento Pattern maintain encapsulation?
• What are some common use cases for the Memento Pattern?

Embrace the Journey

Remember, mastering design patterns is a journey. The Memento Pattern is just one of many tools in your toolkit. As you continue to explore and implement design patterns, you’ll gain a deeper understanding of how to create robust and maintainable software. Keep experimenting, stay curious, and enjoy the journey!

Quiz: Memento Pattern