Memento Pattern Overview

The Memento Pattern, often referred to as the Snapshot Pattern, enables capturing and externalizing an object's internal state without violating encapsulation principles. By storing this state separately, the system supports reverting an object to a previous condition later. This behavioral design pattern essentially provides an undo capability within software systems.

It decouples the state creation logic from the management logic. The originating clas handles its own state capture, while an external manager oversees the stored snapshots. This separation allows the management layer to extend capabilities, such as maintaining a history list or implementing checkpointing features.

Common Applications

Typical use cases involve systems requiring state rollback mechanisms:

• Version control systems (e.g., tracking file revisions).
• Interactive applications (e.g., save states in video games).

When to Apply

Consider this pattern when:

• Persistent snapshots of historical states are required.
• Internal state must be preserved outside the object instance, remaining inaccessible to unrelated classes.

Structural Roles

A standard implementation involves three primary components:

1. Originator: Creates a memento containing its current state and utilizes the memento to revert to saved states.
2. Memento: Holds the state information. Access to the state is restricted so that only the Originator can read or modify it.
3. Caretaker: Manages the lifecycle of the Memento. It stores snapshots but cannot inspect or alter their contents.

Practical Implementation

Below is a Java example illustrating the pattern. Unlike framework-specific integrations, this shows the fundamental mechanics clearly.

public class Editor {
    private String content;

    public void setContent(String content) {
        this.content = content;
    }

    public EditorMemento save() {
        return new EditorMemento(this.content);
    }

    public void restore(EditorMemento memento) {
        if (memento != null) {
            this.content = memento.getContent();
        }
    }
}

class EditorMemento {
    private final String content;

    EditorMemento(String content) {
        this.content = content;
    }

    String getContent() {
        return content;
    }
}

class DocumentHistory {
    private final List<EditorMemento> history = new ArrayList<>();

    public void recordState(Editor editor) {
        history.add(editor.save());
    }

    public EditorMemento getState(int index) {
        return history.get(index);
    }
}

Trade-offs

Benefits:

• Reduces complexity in the Originator class by isolating persistence logic.
• Enforces encapsulation as external managers manage storage without knowing internal details.
• Facilitates easy state reversion.

Drawbacks:

• Memory overhead increases as the number of saved states grows.
• Excessive state snapshots can consume significant system resources.