{"title":"Memento Design Pattern","description":null,"content":"\n\n\n\n\n> **DEFINITION**\n>\n> The **Memento Design Pattern** is a **behavioral design pattern** that lets you **capture and store an object’s internal state** so it can be **restored later**, without violating encapsulation.\n\n\nIt’s particularly useful in situations where:\n\n- You need to implement **undo/redo** functionality.\n- You want to support **checkpointing or versioning** of an object’s state.\n- You want to separate the concerns of **state storage** from **state management logic**.\n\nLet’s walk through a real-world example to see how we can apply the Memento Pattern to solve a problem that involves implementing undo functionality in a text editor.\n\n---\n\n# 1. The Problem: Implementing Undo in a Text Editor\n\nImagine you’re building a simple **text editor**. The editor supports basic operations like:\n\n- `type(String text)` – appends text to the current document\n- `getContent()` – returns the current document text\n- `undo()` – reverts to the previous version of the content\n\nImplementing typing and reading is easy. The real challenge is **undo**.\n\n### The Naive Approach: Client Manages Snapshots\n\nThe most straightforward approach is to have the client manually capture the editor's state before each operation and feed it back during undo:\n\n\n```mermaid\nsequenceDiagram\n participant Client as Client\n participant Editor as TextEditor\n\n Client->>Editor: type(\"Hello\")\n Client->>Editor: getContent()\n Editor-->>Client: \"Hello\"\n Note over Client: Stores \"Hello\" locally\n\n Client->>Editor: type(\" World\")\n Client->>Editor: getContent()\n Editor-->>Client: \"Hello World\"\n Note over Client: Stores \"Hello World\" locally\n\n Client->>Editor: undo(\"Hello\")\n Note over Editor: content = \"Hello\"\n```\n\n\nThe client is doing all the heavy lifting: fetching internal state, storing it, and feeding it back during undo.\n\n\n```java\nclass TextEditorNaive {\n private String content = \"\";\n\n public void type(String newText) {\n content += newText;\n }\n\n public void undo(String previousContent) {\n content = previousContent;\n }\n\n public String getContent() {\n return content;\n }\n}\n```\n\n```python\nclass TextEditorNaive:\n def __init__(self):\n self.content = \"\"\n\n def type(self, new_text):\n self.content += new_text\n\n def undo(self, previous_content):\n self.content = previous_content\n\n def get_content(self):\n return self.content\n```\n\n```cpp\nclass TextEditorNaive {\nprivate:\n string content;\n\npublic:\n TextEditorNaive() : content(\"\") {}\n\n void type(string newText) {\n content += newText;\n }\n\n void undo(string previousContent) {\n content = previousContent;\n }\n\n string getContent() {\n return content;\n }\n};\n```\n\n```go\ntype TextEditorNaive struct {\n\tcontent string\n}\n\nfunc (t *TextEditorNaive) Type(newText string) {\n\tt.content += newText\n}\n\nfunc (t *TextEditorNaive) Undo(previousContent string) {\n\tt.content = previousContent\n}\n\nfunc (t *TextEditorNaive) GetContent() string {\n\treturn t.content\n}\n```\n\n```csharp\nclass TextEditorNaive\n{\n private string content = \"\";\n\n public void Type(string newText)\n {\n content += newText;\n }\n\n public void Undo(string previousContent)\n {\n content = previousContent;\n }\n\n public string GetContent()\n {\n return content;\n }\n}\n```\n\n```typescript\nclass TextEditorNaive {\n private content: string = \"\";\n\n type(newText: string): void {\n this.content += newText;\n }\n\n undo(previousContent: string): void {\n this.content = previousContent;\n }\n\n getContent(): string {\n return this.content;\n }\n}\n```\n\n\nHere is how the client uses it:\n\n\n```java\npublic class TextEditorUndoV1 {\n public static void main(String[] args) {\n TextEditorNaive editor = new TextEditorNaive();\n\n editor.type(\"Hello\");\n String snapshot1 = editor.getContent(); // manual snapshot\n\n editor.type(\" World\");\n String snapshot2 = editor.getContent();\n\n System.out.println(\"Current Content: \" + editor.getContent()); // Hello World\n\n // Undo 1 step\n editor.undo(snapshot1);\n System.out.println(\"After Undo: \" + editor.getContent()); // Hello\n }\n}\n```\n\n```python\nclass TextEditorUndoV1:\n @staticmethod\n def main():\n editor = TextEditorNaive()\n\n editor.type(\"Hello\")\n snapshot1 = editor.get_content() # manual snapshot\n\n editor.type(\" World\")\n snapshot2 = editor.get_content()\n\n print(f\"Current Content: {editor.get_content()}\") # Hello World\n\n # Undo 1 step\n editor.undo(snapshot1)\n print(f\"After Undo: {editor.get_content()}\") # Hello\n```\n\n```cpp\nclass TextEditorUndoV1 {\npublic:\n static void main() {\n TextEditorNaive editor;\n\n editor.type(\"Hello\");\n string snapshot1 = editor.getContent(); // manual snapshot\n\n editor.type(\" World\");\n string snapshot2 = editor.getContent();\n\n cout << \"Current Content: \" << editor.getContent() << endl; // Hello World\n\n // Undo 1 step\n editor.undo(snapshot1);\n cout << \"After Undo: \" << editor.getContent() << endl; // Hello\n }\n};\n```\n\n```go\ntype TextEditorUndoV1 struct{}\n\nfunc (TextEditorUndoV1) main() {\n\teditor := TextEditorNaive{}\n\n\teditor.type(\"Hello\")\n\tsnapshot1 := editor.getContent() // manual snapshot\n\n\teditor.type(\" World\")\n\tsnapshot2 := editor.getContent()\n\n\tprintln(\"Current Content: \" + editor.getContent()) // Hello World\n\n\t// Undo 1 step\n\teditor.undo(snapshot1)\n\tprintln(\"After Undo: \" + editor.getContent()) // Hello\n}\n```\n\n```csharp\npublic class TextEditorUndoV1\n{\n public static void Main()\n {\n TextEditorNaive editor = new TextEditorNaive();\n\n editor.Type(\"Hello\");\n string snapshot1 = editor.GetContent(); // manual snapshot\n\n editor.Type(\" World\");\n string snapshot2 = editor.GetContent();\n\n Console.WriteLine(\"Current Content: \" + editor.GetContent()); // Hello World\n\n // Undo 1 step\n editor.Undo(snapshot1);\n Console.WriteLine(\"After Undo: \" + editor.GetContent()); // Hello\n }\n}\n```\n\n```typescript\nclass TextEditorUndoV1 {\n static main(): void {\n const editor = new TextEditorNaive();\n\n editor.type(\"Hello\");\n const snapshot1 = editor.getContent(); // manual snapshot\n\n editor.type(\" World\");\n const snapshot2 = editor.getContent();\n\n console.log(\"Current Content: \" + editor.getContent()); // Hello World\n\n // Undo 1 step\n editor.undo(snapshot1);\n console.log(\"After Undo: \" + editor.getContent()); // Hello\n }\n}\n```\n\n\n### What’s Wrong with This Design?\n\nWhile this naive implementation works for very basic undo logic, it introduces several **major issues**:\n\n#### 1. Encapsulation is Broken\n\nThe client must call `getContent()` to fetch internal state and pass it directly to `undo()`. This means the client knows that the editor's state is a string called \"content.\" \n\nIf the editor later adds cursor position, selection range, or formatting metadata, the client must be updated to snapshot all of those too. The editor's internal structure has leaked into every class that implements undo.\n\n#### 2. Client Bears the Responsibility\n\nThe client must remember to take a snapshot before every operation. Miss one, and you have a gap in your undo history. This is manual, error-prone, and scatters undo logic across the entire codebase instead of centralizing it.\n\n#### 3. Not Scalable\n\nWhat if the editor's state grows to include cursor position, selection range, font formatting, and scroll position? The client would need to capture all of those fields separately, store them in some custom structure, and feed them all back during undo. The snapshot logic balloons in complexity, and it is all in the wrong place, outside the editor instead of inside it.\n\n#### 4. No Separation of Concerns\n\nThe same code that handles user interactions is also managing state snapshots. This violates the single responsibility principle and makes both the UI code and the undo logic harder to test, maintain, and extend.\n\n### What We Really Need\n\nWe need a design that:\n\n- Lets the **TextEditor** capture and restore its own state without exposing its internals\n- Gives the **client** a way to manage state history without understanding what is inside each snapshot\n- Scales cleanly when the editor's internal state grows more complex\n- Separates undo management from editing logic\n\nThis is exactly what the **Memento pattern** provides.\n\n---\n\n# 2. What is the Memento Pattern\n\n> The **Memento Design Pattern** allows an object to **save and restore its state** without exposing its internal structure. It achieves this by encapsulating the state in a special object called a **Memento**.\n\nTwo characteristics define the Memento pattern:\n\n1. **State capture without exposure.** The originator (the object whose state you want to save) creates a memento that contains a snapshot of its private internal state. The memento does not expose that state to the outside world. Only the originator can read it back. This preserves encapsulation while enabling state restoration.\n2. **External state management.** A separate object called the caretaker stores and manages the mementos. The caretaker decides when to save (before a risky operation) and when to restore (undo). But it never inspects or modifies the memento's contents. It treats each memento as an opaque black box.\n\n### Class Diagram\n\n\n\n\n\nMemento has three participants.\n\n#### 1. Originator (e.g., `TextEditor`)\n\nThe object whose internal state you want to capture and restore.\n\nThe originator is the only participant that touches its own private fields. It packages them into a memento during save, and unpacks them during restore. No other object needs to know what those fields are or how they are structured.\n\n#### 2. Memento (e.g., `TextEditorMemento`)\n\nAn immutable snapshot of the originator's state at a specific point in time. Store the originator's state in a way that prevents external modification\n\n#### 3. Caretaker (e.g., `UndoManager`)\n\nThe external object that decides when to save and restore state. It manages the lifecycle of mementos. It never examines or modifies the content of a memento, it just treats it as a black box.\n\n---\n\n# 3. How It Works\n\nHere is the Memento workflow step by step:\n\n\n```mermaid\nsequenceDiagram\n participant Client as Client\n participant Caretaker as UndoManager\n participant Originator as TextEditor\n participant Memento as Memento\n\n Client->>Caretaker: save(editor)\n Caretaker->>Originator: save()\n Originator->>Memento: new Memento(state)\n Originator-->>Caretaker: memento\n Note over Caretaker: Push onto history stack\n\n Client->>Originator: type(\" World\")\n Note over Originator: state changes\n\n Client->>Caretaker: undo(editor)\n Note over Caretaker: Pop from history stack\n Caretaker->>Originator: restore(memento)\n Originator->>Memento: getState()\n Note over Originator: State restored\n```\n\n\n#### **Step 1: Caretaker requests a save**\n\nBefore the user performs an operation (like typing, deleting, or formatting), the caretaker asks the originator to save its current state.\n\n#### **Step 2: Originator creates a memento**\n\nThe originator reads its own private fields, packages them into a new memento object, and returns it to the caretaker.\n\n#### **Step 3: Caretaker stores the memento**\n\nThe caretaker pushes the memento onto a history stack (or list). It does not open the memento or read its contents.\n\n#### **Step 4: User performs operations**\n\nThe originator's state changes through normal operations (typing text, moving shapes, etc.).\n\n#### **Step 5: User triggers undo**\n\nThe caretaker pops the most recent memento from the history stack and passes it to the originator.\n\n#### **Step 6: Originator restores from the memento**\n\nThe originator reads the state from the memento and overwrites its current fields. The object is now back to exactly how it was when the memento was created.\n\n---\n\n# 4. Implementing Memento Pattern\n\nLet’s refactor our naive text editor into a clean, maintainable design using the **Memento Pattern**. We will create the memento, then the originator, then the caretaker, and finally wire them together in client code.\n\n\n```mermaid\nclassDiagram\n class TextEditor {\n -content: String\n +type(text: String)\n +getContent(): String\n +save(): TextEditorMemento\n +restore(m: TextEditorMemento)\n }\n\n class TextEditorMemento {\n -state: String\n +getState(): String\n }\n\n class TextEditorUndoManager {\n -history: Stack~TextEditorMemento~\n +save(editor: TextEditor)\n +undo(editor: TextEditor)\n }\n\n TextEditor ..> TextEditorMemento : creates\n TextEditorUndoManager --> TextEditorMemento : stores\n TextEditorUndoManager --> TextEditor : calls save/restore\n\n style TextEditor fill:#00ceff,stroke:#000,color:#000\n style TextEditorMemento fill:#ffa94d,stroke:#000,color:#000\n style TextEditorUndoManager fill:#38d9a9,stroke:#000,color:#000\n```\n\n\n### Step 1: Create the Memento - TextEditorMemento\n\nThe memento stores a snapshot of the `TextEditor`'s internal state. It has three important properties:\n\n- **Immutable** — fields are `private final` (or readonly) and cannot be changed after creation\n- **Minimal** — it stores only what is needed for restoration\n- **Encapsulated** — only the originator should read its contents\n\n\n```java\nclass TextEditorMemento {\n private final String state;\n\n public TextEditorMemento(String state) {\n this.state = state;\n }\n\n public String getState() {\n return state;\n }\n}\n```\n\n```python\nclass TextEditorMemento:\n def __init__(self, state):\n self._state = state\n\n def get_state(self):\n return self._state\n```\n\n```cpp\nclass TextEditorMemento {\nprivate:\n string state;\n\npublic:\n TextEditorMemento(string state) : state(state) {}\n\n string getState() {\n return state;\n }\n};\n```\n\n```go\ntype TextEditorMemento struct {\n\tstate string\n}\n\nfunc NewTextEditorMemento(state string) TextEditorMemento {\n\treturn TextEditorMemento{state: state}\n}\n\nfunc (t TextEditorMemento) GetState() string {\n\treturn t.state\n}\n```\n\n```csharp\nclass TextEditorMemento\n{\n private readonly string state;\n\n public TextEditorMemento(string state)\n {\n this.state = state;\n }\n\n public string GetState()\n {\n return state;\n }\n}\n```\n\n```typescript\nclass TextEditorMemento {\n private readonly state: string;\n\n constructor(state: string) {\n this.state = state;\n }\n\n getState(): string {\n return this.state;\n }\n}\n```\n\n\nThis class is passive. It does not contain any logic, just a frozen snapshot of the editor's state at the moment it was created.\n\n### Step 2: Create the Originator – `TextEditor`\n\nThe originator is the object whose state we want to save and restore. It provides two key methods beyond its normal operations:\n\n- `save()` — creates a memento capturing the current state\n- `restore(memento)` — replaces the current state with the state from the memento\n\n\n```java\nclass TextEditor {\n private String content = \"\";\n\n public void type(String newText) {\n content += newText;\n System.out.println(\"Typed: \\\"\" + newText + \"\\\"\");\n }\n\n public String getContent() {\n return content;\n }\n\n public TextEditorMemento save() {\n System.out.println(\"Saving state: \\\"\" + content + \"\\\"\");\n return new TextEditorMemento(content);\n }\n\n public void restore(TextEditorMemento memento) {\n content = memento.getState();\n System.out.println(\"Restored state to: \\\"\" + content + \"\\\"\");\n }\n}\n```\n\n```python\nclass TextEditor:\n def __init__(self):\n self._content = \"\"\n\n def type(self, new_text: str):\n self._content += new_text\n print(f'Typed: \"{new_text}\"')\n\n def get_content(self) -> str:\n return self._content\n\n def save(self) -> TextEditorMemento:\n print(f'Saving state: \"{self._content}\"')\n return TextEditorMemento(self._content)\n\n def restore(self, memento: TextEditorMemento):\n self._content = memento.get_state()\n print(f'Restored state to: \"{self._content}\"')\n```\n\n```cpp\nclass TextEditor {\nprivate:\n string content;\n\npublic:\n TextEditor() : content(\"\") {}\n\n void type(const string& newText) {\n content += newText;\n cout << \"Typed: \\\"\" << newText << \"\\\"\" << endl;\n }\n\n string getContent() const {\n return content;\n }\n\n TextEditorMemento save() {\n cout << \"Saving state: \\\"\" << content << \"\\\"\" << endl;\n return TextEditorMemento(content);\n }\n\n void restore(const TextEditorMemento& memento) {\n content = memento.getState();\n cout << \"Restored state to: \\\"\" << content << \"\\\"\" << endl;\n }\n};\n```\n\n```go\ntype TextEditor struct {\n\tcontent string\n}\n\nfunc (te *TextEditor) Type(newText string) {\n\tte.content += newText\n\tfmt.Printf(\"Typed: \\\"%s\\\"\\n\", newText)\n}\n\nfunc (te *TextEditor) GetContent() string {\n\treturn te.content\n}\n\nfunc (te *TextEditor) Save() TextEditorMemento {\n\tfmt.Printf(\"Saving state: \\\"%s\\\"\\n\", te.content)\n\treturn TextEditorMemento{state: te.content}\n}\n\nfunc (te *TextEditor) Restore(memento TextEditorMemento) {\n\tte.content = memento.GetState()\n\tfmt.Printf(\"Restored state to: \\\"%s\\\"\\n\", te.content)\n}\n```\n\n```csharp\nclass TextEditor\n{\n private string content = \"\";\n\n public void Type(string newText)\n {\n content += newText;\n Console.WriteLine($\"Typed: \\\"{newText}\\\"\");\n }\n\n public string GetContent()\n {\n return content;\n }\n\n public TextEditorMemento Save()\n {\n Console.WriteLine($\"Saving state: \\\"{content}\\\"\");\n return new TextEditorMemento(content);\n }\n\n public void Restore(TextEditorMemento memento)\n {\n content = memento.GetState();\n Console.WriteLine($\"Restored state to: \\\"{content}\\\"\");\n }\n}\n```\n\n```typescript\nclass TextEditor {\n private content: string = \"\";\n\n type(newText: string): void {\n this.content += newText;\n console.log(`Typed: \"${newText}\"`);\n }\n\n getContent(): string {\n return this.content;\n }\n\n save(): TextEditorMemento {\n console.log(`Saving state: \"${this.content}\"`);\n return new TextEditorMemento(this.content);\n }\n\n restore(memento: TextEditorMemento): void {\n this.content = memento.getState();\n console.log(`Restored state to: \"${this.content}\"`);\n }\n}\n```\n\n\nNotice that the `save()` and `restore()` methods are the only ones that interact with the memento. The rest of the editor (typing, getting content) works exactly as before. The memento pattern adds state capture without changing how the object normally operates.\n\n### Step 3: Create the Caretaker – TextEditorUndoManager\n\nThe caretaker manages the history of mementos. It is responsible for:\n\n- Asking the originator to save its state at the right times\n- Storing mementos in a stack (last-in, first-out for undo)\n- Passing mementos back to the originator for restoration\n- Never inspecting or modifying memento contents\n\n\n```java\nclass TextEditorUndoManager {\n private final Stack history = new Stack<>();\n\n public void save(TextEditor editor) {\n history.push(editor.save());\n }\n\n public void undo(TextEditor editor) {\n if (!history.isEmpty()) {\n editor.restore(history.pop());\n } else {\n System.out.println(\"Nothing to undo.\");\n }\n }\n\n public int historySize() {\n return history.size();\n }\n}\n```\n\n```python\nclass TextEditorUndoManager:\n def __init__(self):\n self._history = []\n\n def save(self, editor: TextEditor):\n self._history.append(editor.save())\n\n def undo(self, editor: TextEditor):\n if self._history:\n editor.restore(self._history.pop())\n else:\n print(\"Nothing to undo.\")\n\n def history_size(self) -> int:\n return len(self._history)\n```\n\n```cpp\nclass TextEditorUndoManager {\nprivate:\n stack history;\n\npublic:\n void save(TextEditor& editor) {\n history.push(editor.save());\n }\n\n void undo(TextEditor& editor) {\n if (!history.empty()) {\n editor.restore(history.top());\n history.pop();\n } else {\n cout << \"Nothing to undo.\" << endl;\n }\n }\n\n int historySize() const {\n return history.size();\n }\n};\n```\n\n```go\ntype TextEditorUndoManager struct {\n\thistory []TextEditorMemento\n}\n\nfunc (m *TextEditorUndoManager) Save(editor TextEditor) {\n\tm.history = append(m.history, editor.Save())\n}\n\nfunc (m *TextEditorUndoManager) Undo(editor TextEditor) {\n\tif len(m.history) > 0 {\n\t\tlast := m.history[len(m.history)-1]\n\t\tm.history = m.history[:len(m.history)-1]\n\t\teditor.Restore(last)\n\t} else {\n\t\tprintln(\"Nothing to undo.\")\n\t}\n}\n\nfunc (m *TextEditorUndoManager) HistorySize() int {\n\treturn len(m.history)\n}\n```\n\n```csharp\nclass TextEditorUndoManager\n{\n private readonly Stack history = new Stack();\n\n public void Save(TextEditor editor)\n {\n history.Push(editor.Save());\n }\n\n public void Undo(TextEditor editor)\n {\n if (history.Count > 0)\n {\n editor.Restore(history.Pop());\n }\n else\n {\n Console.WriteLine(\"Nothing to undo.\");\n }\n }\n\n public int HistorySize()\n {\n return history.Count;\n }\n}\n```\n\n```typescript\nclass TextEditorUndoManager {\n private readonly history: TextEditorMemento[] = [];\n\n save(editor: TextEditor): void {\n this.history.push(editor.save());\n }\n\n undo(editor: TextEditor): void {\n if (this.history.length > 0) {\n const memento = this.history.pop()!;\n editor.restore(memento);\n } else {\n console.log(\"Nothing to undo.\");\n }\n }\n\n historySize(): number {\n return this.history.length;\n }\n}\n```\n\n\nThe `TextEditorUndoManager` allows undo operations without the client managing snapshots directly. Notice that `save()` and `undo()` take a `TextEditor` reference but never call `getContent()` or any other method that exposes internal state. They only call `save()` and `restore()`, which return and accept opaque mementos.\n\n### Step 4: Using the Memento from the Client\n\nNow let's put it all together. The client creates an editor and an undo manager, performs operations, saves state at appropriate moments, and undoes when needed.\n\n\n```java\npublic class TextEditorDemo {\n public static void main(String[] args) {\n TextEditor editor = new TextEditor();\n TextEditorUndoManager undoManager = new TextEditorUndoManager();\n\n editor.type(\"Hello\");\n undoManager.save(editor);\n\n editor.type(\" World\");\n undoManager.save(editor);\n\n editor.type(\"!\");\n System.out.println(\"Current: \" + editor.getContent());\n\n System.out.println(\"\\n--- Undo 1 ---\");\n undoManager.undo(editor);\n System.out.println(\"Content: \" + editor.getContent());\n\n System.out.println(\"\\n--- Undo 2 ---\");\n undoManager.undo(editor);\n System.out.println(\"Content: \" + editor.getContent());\n\n System.out.println(\"\\n--- Undo 3 ---\");\n undoManager.undo(editor);\n }\n}\n```\n\n```python\ndef main():\n editor = TextEditor()\n undo_manager = TextEditorUndoManager()\n\n editor.type(\"Hello\")\n undo_manager.save(editor)\n\n editor.type(\" World\")\n undo_manager.save(editor)\n\n editor.type(\"!\")\n print(f\"Current: {editor.get_content()}\")\n\n print(\"\\n--- Undo 1 ---\")\n undo_manager.undo(editor)\n print(f\"Content: {editor.get_content()}\")\n\n print(\"\\n--- Undo 2 ---\")\n undo_manager.undo(editor)\n print(f\"Content: {editor.get_content()}\")\n\n print(\"\\n--- Undo 3 ---\")\n undo_manager.undo(editor)\n\nif __name__ == \"__main__\":\n main()\n```\n\n```cpp\nint main() {\n TextEditor editor;\n TextEditorUndoManager undoManager;\n\n editor.type(\"Hello\");\n undoManager.save(editor);\n\n editor.type(\" World\");\n undoManager.save(editor);\n\n editor.type(\"!\");\n cout << \"Current: \" << editor.getContent() << endl;\n\n cout << \"\\n--- Undo 1 ---\" << endl;\n undoManager.undo(editor);\n cout << \"Content: \" << editor.getContent() << endl;\n\n cout << \"\\n--- Undo 2 ---\" << endl;\n undoManager.undo(editor);\n cout << \"Content: \" << editor.getContent() << endl;\n\n cout << \"\\n--- Undo 3 ---\" << endl;\n undoManager.undo(editor);\n return 0;\n}\n```\n\n```go\neditor := TextEditor{}\nundoManager := TextEditorUndoManager{}\n\neditor.Type(\"Hello\")\nundoManager.Save(&editor)\n\neditor.Type(\" World\")\nundoManager.Save(&editor)\n\neditor.Type(\"!\")\nprintln(\"Current: \" + editor.GetContent())\n\nprintln(\"\\n--- Undo 1 ---\")\nundoManager.Undo(&editor)\nprintln(\"Content: \" + editor.GetContent())\n\nprintln(\"\\n--- Undo 2 ---\")\nundoManager.Undo(&editor)\nprintln(\"Content: \" + editor.GetContent())\n\nprintln(\"\\n--- Undo 3 ---\")\nundoManager.Undo(&editor)\n```\n\n```csharp\nclass Program\n{\n static void Main(string[] args)\n {\n var editor = new TextEditor();\n var undoManager = new TextEditorUndoManager();\n\n editor.Type(\"Hello\");\n undoManager.Save(editor);\n\n editor.Type(\" World\");\n undoManager.Save(editor);\n\n editor.Type(\"!\");\n Console.WriteLine(\"Current: \" + editor.GetContent());\n\n Console.WriteLine(\"\\n--- Undo 1 ---\");\n undoManager.Undo(editor);\n Console.WriteLine(\"Content: \" + editor.GetContent());\n\n Console.WriteLine(\"\\n--- Undo 2 ---\");\n undoManager.Undo(editor);\n Console.WriteLine(\"Content: \" + editor.GetContent());\n\n Console.WriteLine(\"\\n--- Undo 3 ---\");\n undoManager.Undo(editor);\n }\n}\n```\n\n```typescript\nconst editor = new TextEditor();\nconst undoManager = new TextEditorUndoManager();\n\neditor.type(\"Hello\");\nundoManager.save(editor);\n\neditor.type(\" World\");\nundoManager.save(editor);\n\neditor.type(\"!\");\nconsole.log(\"Current: \" + editor.getContent());\n\nconsole.log(\"\\n--- Undo 1 ---\");\nundoManager.undo(editor);\nconsole.log(\"Content: \" + editor.getContent());\n\nconsole.log(\"\\n--- Undo 2 ---\");\nundoManager.undo(editor);\nconsole.log(\"Content: \" + editor.getContent());\n\nconsole.log(\"\\n--- Undo 3 ---\");\nundoManager.undo(editor);\n```\n\n\n#### Expected Output:\n\n\n```shell\nTyped: \"Hello\"\nSaving state: \"Hello\"\nTyped: \" World\"\nSaving state: \"Hello World\"\nTyped: \"!\"\nCurrent: Hello World!\n\n--- Undo 1 ---\nRestored state to: \"Hello World\"\nContent: Hello World\n\n--- Undo 2 ---\nRestored state to: \"Hello\"\nContent: Hello\n\n--- Undo 3 ---\nNothing to undo.\n```\n\n\n### What We Achieved\n\n- **Encapsulation: **Editor’s internal state is never exposed directly to the client\n- **Clean undo logic: **The client doesn’t need to manage or interpret state — it just saves and restores\n- **Separation of concerns: **The `TextEditor` handles state, and the `TextEditorUndoManager` handles history\n- **Scalability: **Easy to extend with redo support, multi-level undo, or persistent versioning\n\n---\n\n# 5. Evolving the System: Adding Cursor Position\n\nWhat happens when the product manager says \"We need to restore cursor position too, not just content\"? With the naive approach, this would be a nightmare. The client would need to capture two fields instead of one, store them in some tuple or object, and know about both when undoing.\n\nWith Memento, the change is entirely inside the originator.\n\n\n```java\n// Updated memento stores both content and cursor position\nclass TextEditorMemento {\n private final String state;\n private final int cursorPosition;\n\n public TextEditorMemento(String state, int cursorPosition) {\n this.state = state;\n this.cursorPosition = cursorPosition;\n }\n\n public String getState() { return state; }\n public int getCursorPosition() { return cursorPosition; }\n}\n\n// Updated editor saves and restores cursor too\nclass TextEditor {\n private String content = \"\";\n private int cursorPosition = 0;\n\n public void type(String newText) {\n content += newText;\n cursorPosition = content.length();\n }\n\n public TextEditorMemento save() {\n return new TextEditorMemento(content, cursorPosition);\n }\n\n public void restore(TextEditorMemento memento) {\n content = memento.getState();\n cursorPosition = memento.getCursorPosition();\n }\n\n // getContent(), getCursorPosition() ...\n}\n\n// UndoManager stays EXACTLY the same. Zero changes.\n```\n\n```python\n# Updated memento stores both content and cursor position\nclass TextEditorMemento:\n def __init__(self, state: str, cursor_position: int):\n self._state = state\n self._cursor_position = cursor_position\n\n def get_state(self) -> str:\n return self._state\n\n def get_cursor_position(self) -> int:\n return self._cursor_position\n\n# Updated editor saves and restores cursor too\nclass TextEditor:\n def __init__(self):\n self._content = \"\"\n self._cursor_position = 0\n\n def type(self, new_text: str):\n self._content += new_text\n self._cursor_position = len(self._content)\n\n def save(self) -> TextEditorMemento:\n return TextEditorMemento(self._content, self._cursor_position)\n\n def restore(self, memento: TextEditorMemento):\n self._content = memento.get_state()\n self._cursor_position = memento.get_cursor_position()\n\n# UndoManager stays EXACTLY the same. Zero changes.\n```\n\n```cpp\n// Updated memento stores both content and cursor position\nclass TextEditorMemento {\nprivate:\n string state;\n int cursorPosition;\n\npublic:\n TextEditorMemento(const string& state, int cursorPosition)\n : state(state), cursorPosition(cursorPosition) {}\n\n string getState() const { return state; }\n int getCursorPosition() const { return cursorPosition; }\n};\n\n// Updated editor saves and restores cursor too\nclass TextEditor {\nprivate:\n string content;\n int cursorPosition = 0;\n\npublic:\n void type(const string& newText) {\n content += newText;\n cursorPosition = content.length();\n }\n\n TextEditorMemento save() {\n return TextEditorMemento(content, cursorPosition);\n }\n\n void restore(const TextEditorMemento& memento) {\n content = memento.getState();\n cursorPosition = memento.getCursorPosition();\n }\n};\n\n// UndoManager stays EXACTLY the same. Zero changes.\n```\n\n```go\n// Updated memento stores both content and cursor position\ntype TextEditorMemento struct {\n\tstate string\n\tcursorPosition int\n}\n\nfunc NewTextEditorMemento(state string, cursorPosition int) TextEditorMemento {\n\treturn TextEditorMemento{state: state, cursorPosition: cursorPosition}\n}\n\nfunc (m TextEditorMemento) GetState() string { return m.state }\nfunc (m TextEditorMemento) GetCursorPosition() int { return m.cursorPosition }\n\n// Updated editor saves and restores cursor too\ntype TextEditor struct {\n\tcontent string\n\tcursorPosition int\n}\n\nfunc (e *TextEditor) Type(newText string) {\n\te.content += newText\n\te.cursorPosition = len(e.content)\n}\n\nfunc (e *TextEditor) Save() TextEditorMemento {\n\treturn NewTextEditorMemento(e.content, e.cursorPosition)\n}\n\nfunc (e *TextEditor) Restore(memento TextEditorMemento) {\n\te.content = memento.GetState()\n\te.cursorPosition = memento.GetCursorPosition()\n}\n\n// UndoManager stays EXACTLY the same. Zero changes.\n```\n\n```csharp\n// Updated memento stores both content and cursor position\nclass TextEditorMemento\n{\n private readonly string state;\n private readonly int cursorPosition;\n\n public TextEditorMemento(string state, int cursorPosition)\n {\n this.state = state;\n this.cursorPosition = cursorPosition;\n }\n\n public string GetState() => state;\n public int GetCursorPosition() => cursorPosition;\n}\n\n// Updated editor saves and restores cursor too\nclass TextEditor\n{\n private string content = \"\";\n private int cursorPosition = 0;\n\n public void Type(string newText)\n {\n content += newText;\n cursorPosition = content.Length;\n }\n\n public TextEditorMemento Save()\n {\n return new TextEditorMemento(content, cursorPosition);\n }\n\n public void Restore(TextEditorMemento memento)\n {\n content = memento.GetState();\n cursorPosition = memento.GetCursorPosition();\n }\n}\n\n// UndoManager stays EXACTLY the same. Zero changes.\n```\n\n```typescript\n// Updated memento stores both content and cursor position\nclass TextEditorMemento {\n constructor(\n private readonly state: string,\n private readonly cursorPosition: number\n ) {}\n\n getState(): string { return this.state; }\n getCursorPosition(): number { return this.cursorPosition; }\n}\n\n// Updated editor saves and restores cursor too\nclass TextEditor {\n private content: string = \"\";\n private cursorPosition: number = 0;\n\n type(newText: string): void {\n this.content += newText;\n this.cursorPosition = this.content.length;\n }\n\n save(): TextEditorMemento {\n return new TextEditorMemento(this.content, this.cursorPosition);\n }\n\n restore(memento: TextEditorMemento): void {\n this.content = memento.getState();\n this.cursorPosition = memento.getCursorPosition();\n }\n}\n\n// UndoManager stays EXACTLY the same. Zero changes.\n```\n\n\nThe undo manager did not change at all. Neither did the client code. The only files that changed were the memento and the editor. This is the Open/Closed Principle at work. You extended the system's capability (restoring cursor position) by modifying only the originator and its memento, without touching any external code.\n\nIf you later add selection range, scroll position, or font formatting, the same principle applies. The memento and editor grow, but the undo manager and client remain untouched.","pageType":"lld-interviews"}

Get Premium