Memento Design Pattern (Behavioral)

Intent

Memento is a behavioral design pattern that lets you save and restore the previous state of an object without revealing the details of its implementation.

---

Problem

Imagine you’re creating a text editor app. In addition to simple text editing, your editor can format text, insert images, etc. At some point, you decide to let users undo any operations carried out on the text.

To implement this, you might try to make the editor record its state before performing any operation. However, most objects have their data stored in private fields. Even if you make them public, any change to the editor class might break the classes that copy its state. You end up with a choice: either expose all internal details of the editor (breaking encapsulation) or make it impossible to save its state.

Solution

The Memento pattern delegates creating the state snapshots to the actual owner of that state, the Originator object. Instead of other objects trying to copy the state from the “outside,” the originator itself produces a special object called a Memento.

The memento is a value object that acts as a snapshot of the originator’s state. It is common practice to make the memento immutable and pass the data only once, via the constructor. Other objects, known as Caretakers, can store these mementos but cannot access or modify the data inside them. When a user triggers an undo, the caretaker gives a memento back to the originator, which uses it to restore its own state.

Real-World Analogy

Think of the Undo feature in a digital camera or a specialized “Save State” in a video game. Before a player enters a boss fight, they save the game. The save file (the Memento) contains all the character’s stats and progress. The player (the Caretaker) keeps the file but can’t change the stats inside it. If the character dies, the game (the Originator) reads the save file and restores the character to the exact state they were in before the fight.

---

Structure

1. Originator: The class that can produce snapshots of its own state and restore its state from snapshots.
2. Memento: A value object that acts as a snapshot.
3. Caretaker: Knows “when” and “why” to capture the originator’s state, but also “when” the state should be restored. It keeps a history of mementos.
4. Encapsulation: In the strict implementation, the memento’s fields are accessible only to the originator that created it.

Structure (Class Diagram)

classDiagram
    class Originator {
        -state: string
        +save() Memento
        +restore(m: Memento)
    }
    class Memento {
        -state: string
        +Memento(state: string)
        +getState() string
    }
    class Caretaker {
        -originator: Originator
        -history: Memento[]
        +undo()
    }

    Originator ..> Memento : creates
    Caretaker o-- Memento : stores
    Caretaker --> Originator : triggers

---

Pseudocode

# The originator holds important state that may change over time.
class Editor:
    private field text, curX, curY, selectionWidth

    method setText(text):
        this.text = text

    # Saves the current state inside a memento.
    method save():
        return new Snapshot(this, text, curX, curY, selectionWidth)

# The memento object stores the past state of the editor.
class Snapshot:
    private field editor: Editor
    private field text, curX, curY, selectionWidth

    constructor Snapshot(editor, text, x, y, width):
        this.editor = editor
        this.text = text
        this.curX = x
        this.curY = y
        this.selectionWidth = width

    # Restores the editor's state.
    method restore():
        editor.setFields(text, curX, curY, selectionWidth)

# The caretaker keeps track of the snapshots.
class Command:
    private field backup: Snapshot

    method makeBackup():
        backup = editor.save()

    method undo():
        if (backup != null):
            backup.restore()

---

Applicability

• Snapshots: Use the Memento pattern when you want to produce snapshots of the object’s state to be able to restore a previous state.
• Encapsulation: Use the pattern when direct access to the object’s fields/getters/setters violates its encapsulation.

How to Implement

1. Determine which class will play the role of the Originator.
2. Create the Memento class and declare a set of fields that mirror the state declared inside the originator.
3. Make the memento class immutable.
4. Add a method for creating mementos to the originator class.
5. Add a method for restoring the originator’s state to its class.
6. The Caretaker should know when to ask the originator for a memento and store it in a stack or list.

---

Pros and Cons

Pros:

• You can produce snapshots of an object’s state without violating its encapsulation.
• You can simplify the originator’s code by letting the caretaker maintain the history of the originator’s state.

Cons:

• The app might consume lots of RAM if clients create mementos too often.
• Caretakers must track the originator’s lifecycle to be able to destroy obsolete mementos.
• Most dynamic programming languages (Python, PHP, JavaScript) can’t guarantee that the state within the memento stays untouched.

Relations with other Design Patterns

• Command and Memento can be used together when implementing “undo”.
• Memento can be used along with Iterator to capture the current iteration state and roll it back if necessary.
• Sometimes Memento can be used along with Prototype if the state you want to store in history is simple and doesn’t require links to external resources.

---

Code Examples

C#

Code Examples (C#)

// Memento
public class Memento
{
    public string State { get; }

    public Memento(string state)
    {
        State = state;
    }
}

// Originator
public class Editor
{
    public string Text { get; set; }

    public Memento Save() => new Memento(Text);

    public void Restore(Memento memento)
    {
        Text = memento.State;
    }
}

// Caretaker
public class History
{
    private readonly Stack<Memento> _states = new();

    public void Push(Memento m) => _states.Push(m);
    public Memento Pop() => _states.Pop();
}

// Usage
class Program
{
    static void Main()
    {
        var editor = new Editor();
        var history = new History();

        editor.Text = "Version 1";
        history.Push(editor.Save());

        editor.Text = "Version 2";
        history.Push(editor.Save());

        editor.Text = "Version 3";

        editor.Restore(history.Pop());
        Console.WriteLine(editor.Text); // Version 2

        editor.Restore(history.Pop());
        Console.WriteLine(editor.Text); // Version 1
    }
}

Python

Code Examples (Python)

from __future__ import annotations
from datetime import datetime
from random import sample
from string import ascii_letters

class Originator():
    """
    The Originator holds some important state that may change over time. It also
    defines a method for saving the state inside a memento and another method for
    restoring the state from it.
    """
    _state = None

    def __init__(self, state: str) -> None:
        self._state = state
        print(f"Originator: My initial state is: {self._state}")

    def do_something(self) -> None:
        print("Originator: I'm doing something important.")
        self._state = "".join(sample(ascii_letters, 10))
        print(f"Originator: and my state has changed to: {self._state}")

    def save(self) -> Memento:
        return ConcreteMemento(self._state)

    def restore(self, memento: Memento) -> None:
        self._state = memento.get_state()
        print(f"Originator: My state has changed to: {self._state}")

class Memento(ABC):
    @abstractmethod
    def get_name(self) -> str:
        pass

    @abstractmethod
    def get_date(self) -> str:
        pass

class ConcreteMemento(Memento):
    def __init__(self, state: str) -> None:
        self._state = state
        self._date = str(datetime.now())[:19]

    def get_state(self) -> str:
        return self._state

    def get_name(self) -> str:
        return f"{self._date} / ({self._state[0:9]}...)"

class Caretaker():
    def __init__(self, originator: Originator) -> None:
        self._mementos = []
        self._originator = originator

    def backup(self) -> None:
        print("\nCaretaker: Saving Originator's state...")
        self._mementos.append(self._originator.save())

    def undo(self) -> None:
        if not len(self._mementos):
            return

        memento = self._mementos.pop()
        print(f"Caretaker: Restoring state to: {memento.get_name()}")
        try:
            self._originator.restore(memento)
        except Exception:
            self.undo()

if __name__ == "__main__":
    originator = Originator("Super-duper-super-puper-awesome.")
    caretaker = Caretaker(originator)

    caretaker.backup()
    originator.do_something()

    caretaker.backup()
    originator.do_something()

    print()
    caretaker.undo()

C++

Code Examples (C++)

#include <iostream>
#include <string>
#include <stack>

// Memento
class Memento {
private:
    std::string state;

public:
    Memento(const std::string& s) : state(s) {}

    const std::string& GetState() const {
        return state;
    }
};

// Originator
class Editor {
private:
    std::string text;

public:
    void SetText(const std::string& t) {
        text = t;
    }

    const std::string& GetText() const {
        return text;
    }

    Memento Save() const {
        return Memento(text);
    }

    void Restore(const Memento& memento) {
        text = memento.GetState();
    }
};

// Caretaker
class History {
private:
    std::stack<Memento> states;

public:
    void Push(const Memento& m) {
        states.push(m);
    }

    Memento Pop() {
        Memento m = states.top();
        states.pop();
        return m;
    }
};

// Usage
int main() {
    Editor editor;
    History history;

    editor.SetText("Version 1");
    history.Push(editor.Save());

    editor.SetText("Version 2");
    history.Push(editor.Save());

    editor.SetText("Version 3");

    editor.Restore(history.Pop());
    std::cout << editor.GetText() << std::endl; // Version 2

    editor.Restore(history.Pop());
    std::cout << editor.GetText() << std::endl; // Version 1

    return 0;
}

Java

Code Examples (Java)

// Memento
public class Memento {

    private final String state;

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

    public String getState() {
        return state;
    }
}

// Originator
public class Editor {

    private String text;

    public void setText(String text) {
        this.text = text;
    }

    public String getText() {
        return text;
    }

    public Memento save() {
        return new Memento(text);
    }

    public void restore(Memento memento) {
        this.text = memento.getState();
    }
}

// Caretaker
import java.util.Stack;

public class History {

    private final Stack<Memento> states = new Stack<>();

    public void push(Memento m) {
        states.push(m);
    }

    public Memento pop() {
        return states.pop();
    }
}

// Usage
public class Program {
    public static void main(String[] args) {

        Editor editor = new Editor();
        History history = new History();

        editor.setText("Version 1");
        history.push(editor.save());

        editor.setText("Version 2");
        history.push(editor.save());

        editor.setText("Version 3");

        editor.restore(history.pop());
        System.out.println(editor.getText()); // Version 2

        editor.restore(history.pop());
        System.out.println(editor.getText()); // Version 1
    }
}

JavaScript

Code Examples (JavaScript)

// Memento
class Memento {
    constructor(state) {
        this.state = state;
    }
}

// Originator
class Editor {
    constructor() {
        this.text = "";
    }

    save() {
        return new Memento(this.text);
    }

    restore(memento) {
        this.text = memento.state;
    }
}

// Caretaker
class History {
    constructor() {
        this.states = [];
    }

    push(memento) {
        this.states.push(memento);
    }

    pop() {
        return this.states.pop();
    }
}

// Usage
const editor = new Editor();
const history = new History();

editor.text = "Version 1";
history.push(editor.save());

editor.text = "Version 2";
history.push(editor.save());

editor.text = "Version 3";

editor.restore(history.pop());
console.log(editor.text); // Version 2

editor.restore(history.pop());
console.log(editor.text); // Version 1

VB

Code Examples (Visual Basic)

' ============================
' Memento
' ============================
Public Class Memento
    Public ReadOnly Property State As String

    Public Sub New(state As String)
        Me.State = state
    End Sub
End Class

' ============================
' Originator
' ============================
Public Class Editor
    Public Property Text As String

    Public Function Save() As Memento
        Return New Memento(Text)
    End Function

    Public Sub Restore(memento As Memento)
        Text = memento.State
    End Sub
End Class

' ============================
' Caretaker
' ============================
Public Class History
    Private ReadOnly _states As New Stack(Of Memento)()

    Public Sub Push(m As Memento)
        _states.Push(m)
    End Sub

    Public Function Pop() As Memento
        Return _states.Pop()
    End Function
End Class

' ============================
' Usage
' ============================
Module Program
    Sub Main()
        Dim editor As New Editor()
        Dim history As New History()

        editor.Text = "Version 1"
        history.Push(editor.Save())

        editor.Text = "Version 2"
        history.Push(editor.Save())

        editor.Text = "Version 3"

        editor.Restore(history.Pop())
        Console.WriteLine(editor.Text) ' Version 2

        editor.Restore(history.Pop())
        Console.WriteLine(editor.Text) ' Version 1
    End Sub
End Module

Rust

Code Examples (Rust)

// Memento
struct Memento {
    state: String,
}

impl Memento {
    fn new(state: &str) -> Self {
        Self {
            state: state.to_string(),
        }
    }
}

// Originator
struct Editor {
    text: String,
}

impl Editor {
    fn new() -> Self {
        Self {
            text: String::new(),
        }
    }

    fn set_text(&mut self, text: &str) {
        self.text = text.to_string();
    }

    fn save(&self) -> Memento {
        Memento::new(&self.text)
    }

    fn restore(&mut self, memento: Memento) {
        self.text = memento.state;
    }
}

// Caretaker
struct History {
    states: Vec<Memento>,
}

impl History {
    fn new() -> Self {
        Self { states: Vec::new() }
    }

    fn push(&mut self, m: Memento) {
        self.states.push(m);
    }

    fn pop(&mut self) -> Memento {
        self.states.pop().expect("No mementos left")
    }
}

// Usage
fn main() {
    let mut editor = Editor::new();
    let mut history = History::new();

    editor.set_text("Version 1");
    history.push(editor.save());

    editor.set_text("Version 2");
    history.push(editor.save());

    editor.set_text("Version 3");

    editor.restore(history.pop());
    println!("{}", editor.text); // Version 2

    editor.restore(history.pop());
    println!("{}", editor.text); // Version 1
}

PHP

Code Examples (PHP)

<?php

// Memento
class Memento
{
    public string $state;

    public function __construct(string $state)
    {
        $this->state = $state;
    }
}

// Originator
class Editor
{
    public string $text = "";

    public function save(): Memento
    {
        return new Memento($this->text);
    }

    public function restore(Memento $memento): void
    {
        $this->text = $memento->state;
    }
}

// Caretaker
class History
{
    /** @var Memento[] */
    private array $states = [];

    public function push(Memento $m): void
    {
        $this->states[] = $m;
    }

    public function pop(): Memento
    {
        return array_pop($this->states);
    }
}

// Usage
$editor = new Editor();
$history = new History();

$editor->text = "Version 1";
$history->push($editor->save());

$editor->text = "Version 2";
$history->push($editor->save());

$editor->text = "Version 3";

$editor->restore($history->pop());
echo $editor->text . "\n"; // Version 2

$editor->restore($history->pop());
echo $editor->text . "\n"; // Version 1

Go

Code Examples (Go)

package main

import (
    "fmt"
)

// Memento
type Memento struct {
    State string
}

func NewMemento(state string) *Memento {
    return &Memento{State: state}
}

// Originator
type Editor struct {
    Text string
}

func (e *Editor) Save() *Memento {
    return NewMemento(e.Text)
}

func (e *Editor) Restore(m *Memento) {
    e.Text = m.State
}

// Caretaker
type History struct {
    states []*Memento
}

func NewHistory() *History {
    return &History{states: []*Memento{}}
}

func (h *History) Push(m *Memento) {
    h.states = append(h.states, m)
}

func (h *History) Pop() *Memento {
    if len(h.states) == 0 {
        return nil
    }
    last := h.states[len(h.states)-1]
    h.states = h.states[:len(h.states)-1]
    return last
}

// Usage
func main() {
    editor := &Editor{}
    history := NewHistory()

    editor.Text = "Version 1"
    history.Push(editor.Save())

    editor.Text = "Version 2"
    history.Push(editor.Save())

    editor.Text = "Version 3"

    editor.Restore(history.Pop())
    fmt.Println(editor.Text) // Version 2

    editor.Restore(history.Pop())
    fmt.Println(editor.Text) // Version 1
}

Ruby

Code Examples (Ruby)

# Memento
class Memento
attr_reader :state

def initialize(state)
    @state = state
end
end

# Originator
class Editor
attr_accessor :text

def save
    Memento.new(@text)
end

def restore(memento)
    @text = memento.state
end
end

# Caretaker
class History
def initialize
    @states = []
end

def push(memento)
    @states << memento
end

def pop
    @states.pop
end
end

# Usage
editor = Editor.new
history = History.new

editor.text = "Version 1"
history.push(editor.save)

editor.text = "Version 2"
history.push(editor.save)

editor.text = "Version 3"

editor.restore(history.pop)
puts editor.text   # Version 2

editor.restore(history.pop)
puts editor.text   # Version 1

Perl

Code Examples (Perl)

#!/usr/bin/perl
use strict;
use warnings;

############################
# Memento
############################
package Memento;

sub new {
    my ($class, $state) = @_;
    return bless { state => $state }, $class;
}

sub get_state {
    my ($self) = @_;
    return $self->{state};
}

############################
# Originator
############################
package Editor;

sub new {
    my ($class) = @_;
    return bless { text => "" }, $class;
}

sub set_text {
    my ($self, $text) = @_;
    $self->{text} = $text;
}

sub get_text {
    my ($self) = @_;
    return $self->{text};
}

sub save {
    my ($self) = @_;
    return Memento->new($self->{text});
}

sub restore {
    my ($self, $memento) = @_;
    $self->{text} = $memento->get_state();
}

############################
# Caretaker
############################
package History;

sub new {
    my ($class) = @_;
    return bless { states => [] }, $class;
}

sub push {
    my ($self, $memento) = @_;
    push @{ $self->{states} }, $memento;
}

sub pop {
    my ($self) = @_;
    return pop @{ $self->{states} };
}

############################
# Usage
############################
package main;

my $editor  = Editor->new();
my $history = History->new();

$editor->set_text("Version 1");
$history->push($editor->save());

$editor->set_text("Version 2");
$history->push($editor->save());

$editor->set_text("Version 3");

$editor->restore($history->pop());
print $editor->get_text(), "\n";   # Version 2

$editor->restore($history->pop());
print $editor->get_text(), "\n";   # Version 1

TypeScript

Code Examples (TypeScript)

// Memento
class Memento {
    state: string;

    constructor(state: string) {
        this.state = state;
    }
}

// Originator
class Editor {
    text: string = "";

    save(): Memento {
        return new Memento(this.text);
    }

    restore(memento: Memento): void {
        this.text = memento.state;
    }
}

// Caretaker
class History {
    private states: Memento[] = [];

    push(m: Memento): void {
        this.states.push(m);
    }

    pop(): Memento {
        return this.states.pop()!;
    }
}

// Usage
const editor = new Editor();
const history = new History();

editor.text = "Version 1";
history.push(editor.save());

editor.text = "Version 2";
history.push(editor.save());

editor.text = "Version 3";

editor.restore(history.pop());
console.log(editor.text); // Version 2

editor.restore(history.pop());
console.log(editor.text); // Version 1

---