{"title":"State Design Pattern","description":null,"content":"\n```mermaid\nstateDiagram-v2\n [*] --> StateA: Initial\n\n StateA --> StateB: action1()\n StateB --> StateC: action2()\n StateC --> StateA: action3()\n\n StateB --> StateA: cancel()\n\n classDef stateA fill:#00ceff,stroke:#000,color:#000\n classDef stateB fill:#ffa94d,stroke:#000,color:#000\n classDef stateC fill:#69db7c,stroke:#000,color:#000\n\n class StateA stateA\n class StateB stateB\n class StateC stateC\n```\n\n\n\n> **DEFINITION**\n>\n> The **State Design Pattern** is a **behavioral design pattern** that lets an object **change its behavior when its internal state changes**, as if it were switching to a different class at runtime.\n\n\nIt’s particularly useful in situations where:\n\n- An object can be in one of **many distinct states**, each with different behavior.\n- The object’s behavior depends on **current context**, and that context **changes over time**.\n- You want to avoid large, monolithic `if-else` or `switch` statements that check for every possible state.\n\nLet’s walk through a real-world example to see how we can apply the State Pattern to manage dynamic behavior in a clean, scalable, and object-oriented way.\n\n---\n\n# \n\n# 1. The Problem: Managing Vending Machine States\n\nImagine you're building a simple [**vending machine system**](https://en.wikipedia.org/wiki/Vending_machine). On the surface, it seems straightforward: accept money, dispense products, and go back to idle.\n\n\n\n\n\nBut the tricky part is that the machine’s behavior must change depending on what’s happening right now. A vending machine can be in only one state at a time, for example:\n\n- **IdleState:** Waiting for user input (nothing selected, no money inserted).\n- **ItemSelectedState:** An item has been selected, waiting for payment.\n- **HasMoneyState:** Money has been inserted, waiting to dispense the selected item.\n- **DispensingState:** The machine is actively dispensing the item.\n\nThe machine supports a few user-facing operations:\n\n- `selectItem(String itemCode)` – Select an item to purchase\n- `insertCoin(double amount)` – Insert payment for the selected item\n- `dispenseItem()` – Trigger the item dispensing process\n\nEach of these methods should behave differently based on the machine's current state.\n\nFor example, calling `dispenseItem()` while the machine is in `IdleState` should do nothing or show an error. Calling `insertCoin()` before selecting an item should be disallowed. Calling `selectItem()` during `DispensingState` should be ignored until the item is dispensed.\n\n---\n\n### The Naive Approach\n\nA common but flawed approach is to manage state transitions manually inside a monolithic `VendingMachine` class using `if-else` or `switch` statements.\n\n\n```java\nclass VendingMachine {\n\n private enum State {\n IDLE, ITEM_SELECTED, HAS_MONEY, DISPENSING\n }\n\n private State currentState = State.IDLE;\n private String selectedItem = \"\";\n private double insertedAmount = 0.0;\n\n public void selectItem(String itemCode) {\n switch (currentState) {\n case IDLE:\n selectedItem = itemCode;\n currentState = State.ITEM_SELECTED;\n break;\n case ITEM_SELECTED:\n System.out.println(\"Item already selected\");\n break;\n case HAS_MONEY:\n System.out.println(\"Payment already received for item\");\n break;\n case DISPENSING:\n System.out.println(\"Currently dispensing\");\n break;\n }\n }\n\n public void insertCoin(double amount) {\n switch (currentState) {\n case IDLE:\n System.out.println(\"No item selected\");\n break;\n case ITEM_SELECTED:\n insertedAmount = amount;\n System.out.println(\"Inserted $\" + amount + \" for item\");\n currentState = State.HAS_MONEY;\n break;\n case HAS_MONEY:\n System.out.println(\"Money already inserted\");\n break;\n case DISPENSING:\n System.out.println(\"Currently dispensing\");\n break;\n }\n }\n\n public void dispenseItem() {\n switch (currentState) {\n case IDLE:\n System.out.println(\"No item selected\");\n break;\n case ITEM_SELECTED:\n System.out.println(\"Please insert coin first\");\n break;\n case HAS_MONEY:\n System.out.println(\"Dispensing item '\" + selectedItem + \"'\");\n currentState = State.DISPENSING;\n System.out.println(\"Item dispensed successfully.\");\n resetMachine();\n break;\n case DISPENSING:\n System.out.println(\"Already dispensing. Please wait.\");\n break;\n }\n }\n\n private void resetMachine() {\n selectedItem = \"\";\n insertedAmount = 0.0;\n currentState = State.IDLE;\n }\n}\n```\n\n```python\nfrom enum import Enum\n\nclass State(Enum):\n IDLE = 1\n ITEM_SELECTED = 2\n HAS_MONEY = 3\n DISPENSING = 4\n\nclass VendingMachine:\n def __init__(self):\n self.current_state = State.IDLE\n self.selected_item = \"\"\n self.inserted_amount = 0.0\n\n def select_item(self, item_code):\n if self.current_state == State.IDLE:\n self.selected_item = item_code\n self.current_state = State.ITEM_SELECTED\n elif self.current_state == State.ITEM_SELECTED:\n print(\"Item already selected\")\n elif self.current_state == State.HAS_MONEY:\n print(\"Payment already received for item\")\n elif self.current_state == State.DISPENSING:\n print(\"Currently dispensing\")\n\n def insert_coin(self, amount):\n if self.current_state == State.IDLE:\n print(\"No item selected\")\n elif self.current_state == State.ITEM_SELECTED:\n self.inserted_amount = amount\n print(f\"Inserted ${amount} for item\")\n self.current_state = State.HAS_MONEY\n elif self.current_state == State.HAS_MONEY:\n print(\"Money already inserted\")\n elif self.current_state == State.DISPENSING:\n print(\"Currently dispensing\")\n\n def dispense_item(self):\n if self.current_state == State.IDLE:\n print(\"No item selected\")\n elif self.current_state == State.ITEM_SELECTED:\n print(\"Please insert coin first\")\n elif self.current_state == State.HAS_MONEY:\n print(f\"Dispensing item '{self.selected_item}'\")\n self.current_state = State.DISPENSING\n print(\"Item dispensed successfully.\")\n self._reset_machine()\n elif self.current_state == State.DISPENSING:\n print(\"Already dispensing. Please wait.\")\n\n def _reset_machine(self):\n self.selected_item = \"\"\n self.inserted_amount = 0.0\n self.current_state = State.IDLE\n```\n\n```cpp\nenum State {\n IDLE, ITEM_SELECTED, HAS_MONEY, DISPENSING\n};\n\nclass VendingMachine {\nprivate:\n State currentState;\n string selectedItem;\n double insertedAmount;\n\npublic:\n VendingMachine() : currentState(IDLE), selectedItem(\"\"), insertedAmount(0.0) {}\n\n void selectItem(string itemCode) {\n switch (currentState) {\n case IDLE:\n selectedItem = itemCode;\n currentState = ITEM_SELECTED;\n break;\n case ITEM_SELECTED:\n cout << \"Item already selected\" << endl;\n break;\n case HAS_MONEY:\n cout << \"Payment already received for item\" << endl;\n break;\n case DISPENSING:\n cout << \"Currently dispensing\" << endl;\n break;\n }\n }\n\n void insertCoin(double amount) {\n switch (currentState) {\n case IDLE:\n cout << \"No item selected\" << endl;\n break;\n case ITEM_SELECTED:\n insertedAmount = amount;\n cout << \"Inserted $\" << amount << \" for item\" << endl;\n currentState = HAS_MONEY;\n break;\n case HAS_MONEY:\n cout << \"Money already inserted\" << endl;\n break;\n case DISPENSING:\n cout << \"Currently dispensing\" << endl;\n break;\n }\n }\n\n void dispenseItem() {\n switch (currentState) {\n case IDLE:\n cout << \"No item selected\" << endl;\n break;\n case ITEM_SELECTED:\n cout << \"Please insert coin first\" << endl;\n break;\n case HAS_MONEY:\n cout << \"Dispensing item '\" << selectedItem << \"'\" << endl;\n currentState = DISPENSING;\n cout << \"Item dispensed successfully.\" << endl;\n resetMachine();\n break;\n case DISPENSING:\n cout << \"Already dispensing. Please wait.\" << endl;\n break;\n }\n }\n\n void resetMachine() {\n selectedItem = \"\";\n insertedAmount = 0.0;\n currentState = IDLE;\n }\n};\n```\n\n```go\ntype State int\n\nconst (\n\tIDLE State = iota\n\tITEM_SELECTED\n\tHAS_MONEY\n\tDISPENSING\n)\n\ntype VendingMachine struct {\n\tcurrentState State\n\tselectedItem string\n\tinsertedAmount float64\n}\n\nfunc (vm *VendingMachine) SelectItem(itemCode string) {\n\tswitch vm.currentState {\n\tcase IDLE:\n\t\tvm.selectedItem = itemCode\n\t\tvm.currentState = ITEM_SELECTED\n\tcase ITEM_SELECTED:\n\t\tfmt.Println(\"Item already selected\")\n\tcase HAS_MONEY:\n\t\tfmt.Println(\"Payment already received for item\")\n\tcase DISPENSING:\n\t\tfmt.Println(\"Currently dispensing\")\n\t}\n}\n\nfunc (vm *VendingMachine) InsertCoin(amount float64) {\n\tswitch vm.currentState {\n\tcase IDLE:\n\t\tfmt.Println(\"No item selected\")\n\tcase ITEM_SELECTED:\n\t\tvm.insertedAmount = amount\n\t\tfmt.Println(\"Inserted $\" + strconv.FormatFloat(amount, 'f', -1, 64) + \" for item\")\n\t\tvm.currentState = HAS_MONEY\n\tcase HAS_MONEY:\n\t\tfmt.Println(\"Money already inserted\")\n\tcase DISPENSING:\n\t\tfmt.Println(\"Currently dispensing\")\n\t}\n}\n\nfunc (vm *VendingMachine) DispenseItem() {\n\tswitch vm.currentState {\n\tcase IDLE:\n\t\tfmt.Println(\"No item selected\")\n\tcase ITEM_SELECTED:\n\t\tfmt.Println(\"Please insert coin first\")\n\tcase HAS_MONEY:\n\t\tfmt.Println(\"Dispensing item '\" + vm.selectedItem + \"'\")\n\t\tvm.currentState = DISPENSING\n\t\tfmt.Println(\"Item dispensed successfully.\")\n\t\tvm.resetMachine()\n\tcase DISPENSING:\n\t\tfmt.Println(\"Already dispensing. Please wait.\")\n\t}\n}\n\nfunc (vm *VendingMachine) resetMachine() {\n\tvm.selectedItem = \"\"\n\tvm.insertedAmount = 0.0\n\tvm.currentState = IDLE\n}\n```\n\n```csharp\nenum State\n{\n IDLE, ITEM_SELECTED, HAS_MONEY, DISPENSING\n}\n\nclass VendingMachine\n{\n private State currentState = State.IDLE;\n private string selectedItem = \"\";\n private double insertedAmount = 0.0;\n\n public void SelectItem(string itemCode)\n {\n switch (currentState)\n {\n case State.IDLE:\n selectedItem = itemCode;\n currentState = State.ITEM_SELECTED;\n break;\n case State.ITEM_SELECTED:\n Console.WriteLine(\"Item already selected\");\n break;\n case State.HAS_MONEY:\n Console.WriteLine(\"Payment already received for item\");\n break;\n case State.DISPENSING:\n Console.WriteLine(\"Currently dispensing\");\n break;\n }\n }\n\n public void InsertCoin(double amount)\n {\n switch (currentState)\n {\n case State.IDLE:\n Console.WriteLine(\"No item selected\");\n break;\n case State.ITEM_SELECTED:\n insertedAmount = amount;\n Console.WriteLine(\"Inserted $\" + amount + \" for item\");\n currentState = State.HAS_MONEY;\n break;\n case State.HAS_MONEY:\n Console.WriteLine(\"Money already inserted\");\n break;\n case State.DISPENSING:\n Console.WriteLine(\"Currently dispensing\");\n break;\n }\n }\n\n public void DispenseItem()\n {\n switch (currentState)\n {\n case State.IDLE:\n Console.WriteLine(\"No item selected\");\n break;\n case State.ITEM_SELECTED:\n Console.WriteLine(\"Please insert coin first\");\n break;\n case State.HAS_MONEY:\n Console.WriteLine(\"Dispensing item '\" + selectedItem + \"'\");\n currentState = State.DISPENSING;\n Console.WriteLine(\"Item dispensed successfully.\");\n ResetMachine();\n break;\n case State.DISPENSING:\n Console.WriteLine(\"Already dispensing. Please wait.\");\n break;\n }\n }\n\n private void ResetMachine()\n {\n selectedItem = \"\";\n insertedAmount = 0.0;\n currentState = State.IDLE;\n }\n}\n```\n\n```typescript\nenum StateEnum {\n IDLE = \"IDLE\",\n ITEM_SELECTED = \"ITEM_SELECTED\",\n HAS_MONEY = \"HAS_MONEY\",\n DISPENSING = \"DISPENSING\"\n}\n\nclass VendingMachine {\n private currentState: StateEnum = StateEnum.IDLE;\n private selectedItem: string = \"\";\n private insertedAmount: number = 0.0;\n\n selectItem(itemCode: string): void {\n switch (this.currentState) {\n case StateEnum.IDLE:\n this.selectedItem = itemCode;\n this.currentState = StateEnum.ITEM_SELECTED;\n break;\n case StateEnum.ITEM_SELECTED:\n console.log(\"Item already selected\");\n break;\n case StateEnum.HAS_MONEY:\n console.log(\"Payment already received for item\");\n break;\n case StateEnum.DISPENSING:\n console.log(\"Currently dispensing\");\n break;\n }\n }\n\n insertCoin(amount: number): void {\n switch (this.currentState) {\n case StateEnum.IDLE:\n console.log(\"No item selected\");\n break;\n case StateEnum.ITEM_SELECTED:\n this.insertedAmount = amount;\n console.log(\"Inserted $\" + amount + \" for item\");\n this.currentState = StateEnum.HAS_MONEY;\n break;\n case StateEnum.HAS_MONEY:\n console.log(\"Money already inserted\");\n break;\n case StateEnum.DISPENSING:\n console.log(\"Currently dispensing\");\n break;\n }\n }\n\n dispenseItem(): void {\n switch (this.currentState) {\n case StateEnum.IDLE:\n console.log(\"No item selected\");\n break;\n case StateEnum.ITEM_SELECTED:\n console.log(\"Please insert coin first\");\n break;\n case StateEnum.HAS_MONEY:\n console.log(\"Dispensing item '\" + this.selectedItem + \"'\");\n this.currentState = StateEnum.DISPENSING;\n console.log(\"Item dispensed successfully.\");\n this.resetMachine();\n break;\n case StateEnum.DISPENSING:\n console.log(\"Already dispensing. Please wait.\");\n break;\n }\n }\n\n private resetMachine(): void {\n this.selectedItem = \"\";\n this.insertedAmount = 0.0;\n this.currentState = StateEnum.IDLE;\n }\n}\n```\n\n\n### What's Wrong with This Approach?\n\nWhile using an `enum` with `switch` statements can work for small, predictable systems, this approach **doesn't scale well**.\n\n#### 1. Cluttered Code\n\nAll state-related logic is stuffed into a single class (`VendingMachine`), resulting in large and repetitive `switch` or `if-else` blocks across every method. This leads to code that is hard to read and reason about, duplicate checks for state across multiple methods, and fragile logic when multiple developers touch the same file.\n\n#### 2. Hard to Extend\n\nSuppose you want to introduce new states like `OutOfStockState` (when the selected item is sold out) or `MaintenanceState` (when the machine is undergoing service). To support these, you would need to update every switch block in every method, add logic in multiple places, and risk breaking existing functionality. This violates the Open/Closed Principle.\n\nThis violates the **Open/Closed Principle:** the system is open to modification when it should be open to extension.\n\n#### 3. Violates the Single Responsibility Principle\n\nThe `VendingMachine` class is now responsible for managing state transitions, implementing business rules, and executing state-specific logic. This tight coupling makes the class monolithic, hard to test, and resistant to change.\n\n### What We Really Need\n\nWe need to encapsulate the behavior associated with each state into its own class, so the vending machine can delegate work to the current state object instead of managing it all internally. This would allow us to avoid switch-case madness, add or remove states without modifying the core class, and keep each state's logic isolated and testable.\n\nThis is exactly what the **State Design Pattern** enables.\n\n---\n\n# 2. The State Pattern\n\n> The State pattern allows an object (the Context) to alter its behavior when its internal state changes. The object appears to change its class because its behavior is now delegated to a different state object.\n\nTwo characteristics define the pattern:\n\n1. **Encapsulation of state-specific behavior:** Each state gets its own class. All the logic for \"what happens when the machine is idle and someone inserts a coin\" lives in the `IdleState` class, not buried in a switch statement somewhere.\n2. **State-driven transitions:** State objects themselves decide when and how to transition to another state. The context does not manage transitions through conditionals. It just delegates to the current state, and the state handles the rest.\n\n\n> **Real-World Analogy**\n>\n> Think about a traffic light. It has three states: red, yellow, and green. The behavior at each state is different: cars stop, cars prepare to stop, or cars go.\n>\n> Each state knows what it does and when to transition to the next one. Red knows it should eventually become green. Green knows it should eventually become yellow. The traffic light itself just follows whichever state is active. \n>\n> That is exactly how the State pattern works: the context (traffic light) delegates to the current state, and each state manages its own transitions.\n\n\n---\n\n## Class Diagram\n\n\n```mermaid\nclassDiagram\n class State {\n <>\n +handleAction(context)\n }\n\n class ConcreteStateA {\n +handleAction(context)\n }\n\n class ConcreteStateB {\n +handleAction(context)\n }\n\n class ConcreteStateC {\n +handleAction(context)\n }\n\n class Context {\n -state: State\n +setState(State)\n +request()\n }\n\n State <|.. ConcreteStateA\n State <|.. ConcreteStateB\n State <|.. ConcreteStateC\n Context --> State : delegates to\n\n style State fill:#00ceff,stroke:#000,color:#000\n style ConcreteStateA fill:#ffa94d,stroke:#000,color:#000\n style ConcreteStateB fill:#ffa94d,stroke:#000,color:#000\n style ConcreteStateC fill:#ffa94d,stroke:#000,color:#000\n style Context fill:#38d9a9,stroke:#000,color:#000\n```\n\n\n#### 1. State Interface (e.g., `MachineState`)\n\nDeclares the methods that correspond to the actions the context supports. Every concrete state must implement these methods, even if some are no-ops in certain states.\n\nThe State interface usually passes the context as a parameter to each method. This lets concrete states call `context.setState(new SomeOtherState())` to trigger transitions.\n\n#### 2. Concrete States (e.g., `IdleState`, `ItemSelectedState`)\n\nEach concrete state implements the State interface with behavior specific to that state.\n\nWhen an action in one state should move the context to a different state, the concrete state creates the next state object and sets it on the context.\n\n#### 3. Context (e.g., `VendingMachine`)\n\nThe class that clients interact with. It maintains a reference to the current State object and delegates all operations to it.\n\n---\n\n# 3. How it Works\n\nThe State workflow follows a delegation-and-transition cycle:\n\n\n```mermaid\nsequenceDiagram\n participant Client\n participant Context as VendingMachine\n participant Idle as IdleState\n participant Selected as ItemSelectedState\n participant HasMoney as HasMoneyState\n\n Client->>Context: selectItem(\"A1\")\n Context->>Idle: selectItem(context, \"A1\")\n Idle->>Context: setState(ItemSelectedState)\n\n Client->>Context: insertCoin(1.50)\n Context->>Selected: insertCoin(context, 1.50)\n Selected->>Context: setState(HasMoneyState)\n\n Client->>Context: dispenseItem()\n Context->>HasMoney: dispenseItem(context)\n HasMoney->>Context: setState(IdleState) + reset()\n```\n\n\n**Step 1:** The context starts with an initial state (e.g., `IdleState`).\n\n**Step 2:** The client calls an action on the context (e.g., `selectItem(\"A1\")`).\n\n**Step 3:** The context delegates the call to the current state: `currentState.selectItem(this, \"A1\")`.\n\n**Step 4:** The state performs its logic. If the action triggers a transition, the state creates a new state object and calls `context.setState(newState)`.\n\n**Step 5:** The next time the client calls an action, the context delegates to the new state, which may behave completely differently.\n\n---\n\n# 4. Implementing State Pattern\n\nInstead of hardcoding state transitions and behaviors into a single monolithic class using `if-else` or `switch` statements, we’ll apply the **State Pattern** to separate concerns and make the vending machine easier to manage and extend.\n\n### State Diagram\n\n\n```mermaid\nstateDiagram-v2\n [*] --> Idle: Power on\n\n Idle --> ItemSelected: selectItem()\n ItemSelected --> Idle: cancel()\n ItemSelected --> HasMoney: insertMoney()\n HasMoney --> Dispensing: dispense()\n HasMoney --> ItemSelected: cancel()
(refund)\n Dispensing --> Idle: complete()\n\n classDef idle fill:#00ceff,stroke:#000,color:#000\n classDef selected fill:#ffa94d,stroke:#000,color:#000\n classDef money fill:#69db7c,stroke:#000,color:#000\n classDef dispensing fill:#9775fa,stroke:#000,color:#000\n\n class Idle idle\n class ItemSelected selected\n class HasMoney money\n class Dispensing dispensing\n```\n\n\n### Step 1: Define the State Interface\n\nThe first step is to define a `MachineState` interface that declares all the operations the vending machine supports. Each state will implement this interface, defining how the vending machine should behave when in that state.\n\n\n```java\ninterface MachineState {\n void selectItem(VendingMachine context, String itemCode);\n void insertCoin(VendingMachine context, double amount);\n void dispenseItem(VendingMachine context);\n}\n```\n\n```python\nfrom abc import ABC, abstractmethod\n\nclass MachineState(ABC):\n @abstractmethod\n def select_item(self, context, item_code):\n pass\n\n @abstractmethod\n def insert_coin(self, context, amount):\n pass\n\n @abstractmethod\n def dispense_item(self, context):\n pass\n```\n\n```cpp\nclass VendingMachine; // Forward declaration\n\nclass MachineState {\npublic:\n virtual ~MachineState() = default;\n virtual void selectItem(VendingMachine* context, string itemCode) = 0;\n virtual void insertCoin(VendingMachine* context, double amount) = 0;\n virtual void dispenseItem(VendingMachine* context) = 0;\n};\n```\n\n```go\ntype MachineState interface {\n\tSelectItem(context *VendingMachine, itemCode string)\n\tInsertCoin(context *VendingMachine, amount float64)\n\tDispenseItem(context *VendingMachine)\n}\n```\n\n```csharp\ninterface IMachineState\n{\n void SelectItem(VendingMachine context, string itemCode);\n void InsertCoin(VendingMachine context, double amount);\n void DispenseItem(VendingMachine context);\n}\n```\n\n```typescript\ninterface MachineState {\n selectItem(context: VendingMachine, itemCode: string): void;\n insertCoin(context: VendingMachine, amount: number): void;\n dispenseItem(context: VendingMachine): void;\n}\n```\n\n\nNotice how every method takes the context as a parameter. This allows each state to read context data (like the selected item) and trigger transitions by calling `context.setState(...)`.\n\n### Step 2: Implement Concrete State Classes\n\nEach state class implements the `MachineState` interface and defines its behavior for each operation.\n\n#### IdleState\n\nThe machine is waiting for user input. The only valid action is selecting an item. Inserting coins or dispensing without selecting first should be rejected.\n\n\n```java\nclass IdleState implements MachineState {\n @Override\n public void selectItem(VendingMachine context, String itemCode) {\n System.out.println(\"Item selected: \" + itemCode);\n context.setSelectedItem(itemCode);\n context.setState(new ItemSelectedState());\n }\n\n @Override\n public void insertCoin(VendingMachine context, double amount) {\n System.out.println(\"Please select an item before inserting coins.\");\n }\n\n @Override\n public void dispenseItem(VendingMachine context) {\n System.out.println(\"No item selected. Nothing to dispense.\");\n }\n}\n```\n\n```python\nclass IdleState(MachineState):\n def select_item(self, context, item_code):\n print(f\"Item selected: {item_code}\")\n context.set_selected_item(item_code)\n context.set_state(ItemSelectedState())\n\n def insert_coin(self, context, amount):\n print(\"Please select an item before inserting coins.\")\n\n def dispense_item(self, context):\n print(\"No item selected. Nothing to dispense.\")\n```\n\n```cpp\nclass IdleState : public MachineState {\npublic:\n void selectItem(VendingMachine* context, string itemCode) override {\n cout << \"Item selected: \" << itemCode << endl;\n context->setSelectedItem(itemCode);\n context->setState(new ItemSelectedState());\n }\n\n void insertCoin(VendingMachine* context, double amount) override {\n cout << \"Please select an item before inserting coins.\" << endl;\n }\n\n void dispenseItem(VendingMachine* context) override {\n cout << \"No item selected. Nothing to dispense.\" << endl;\n }\n};\n```\n\n```go\ntype IdleState struct{}\n\nfunc (s *IdleState) SelectItem(context *VendingMachine, itemCode string) {\n\tfmt.Println(\"Item selected: \" + itemCode)\n\tcontext.SetSelectedItem(itemCode)\n\tcontext.SetState(&ItemSelectedState{})\n}\n\nfunc (s *IdleState) InsertCoin(context *VendingMachine, amount float64) {\n\tfmt.Println(\"Please select an item before inserting coins.\")\n}\n\nfunc (s *IdleState) DispenseItem(context *VendingMachine) {\n\tfmt.Println(\"No item selected. Nothing to dispense.\")\n}\n```\n\n```csharp\nclass IdleState : IMachineState\n{\n public void SelectItem(VendingMachine context, string itemCode)\n {\n Console.WriteLine(\"Item selected: \" + itemCode);\n context.SetSelectedItem(itemCode);\n context.SetState(new ItemSelectedState());\n }\n\n public void InsertCoin(VendingMachine context, double amount)\n {\n Console.WriteLine(\"Please select an item before inserting coins.\");\n }\n\n public void DispenseItem(VendingMachine context)\n {\n Console.WriteLine(\"No item selected. Nothing to dispense.\");\n }\n}\n```\n\n```typescript\nclass IdleState implements MachineState {\n selectItem(context: VendingMachine, itemCode: string): void {\n console.log(\"Item selected: \" + itemCode);\n context.setSelectedItem(itemCode);\n context.setState(new ItemSelectedState());\n }\n\n insertCoin(context: VendingMachine, amount: number): void {\n console.log(\"Please select an item before inserting coins.\");\n }\n\n dispenseItem(context: VendingMachine): void {\n console.log(\"No item selected. Nothing to dispense.\");\n }\n}\n```\n\n\n#### ItemSelectedState\n\nAn item has been selected, and the machine is waiting for payment. The only valid action here is inserting a coin.\n\n\n```java\nclass ItemSelectedState implements MachineState {\n @Override\n public void selectItem(VendingMachine context, String itemCode) {\n System.out.println(\"Item already selected: \" + context.getSelectedItem());\n }\n\n @Override\n public void insertCoin(VendingMachine context, double amount) {\n System.out.println(\"Inserted $\" + amount + \" for item: \" + context.getSelectedItem());\n context.setInsertedAmount(amount);\n context.setState(new HasMoneyState());\n }\n\n @Override\n public void dispenseItem(VendingMachine context) {\n System.out.println(\"Insert coin before dispensing.\");\n }\n}\n```\n\n```python\nclass ItemSelectedState(MachineState):\n def select_item(self, context, item_code):\n print(f\"Item already selected: {context.get_selected_item()}\")\n\n def insert_coin(self, context, amount):\n print(f\"Inserted ${amount} for item: {context.get_selected_item()}\")\n context.set_inserted_amount(amount)\n context.set_state(HasMoneyState())\n\n def dispense_item(self, context):\n print(\"Insert coin before dispensing.\")\n```\n\n```cpp\nclass ItemSelectedState : public MachineState {\npublic:\n void selectItem(VendingMachine* context, string itemCode) override {\n cout << \"Item already selected: \" << context->getSelectedItem() << endl;\n }\n\n void insertCoin(VendingMachine* context, double amount) override {\n cout << \"Inserted $\" << amount << \" for item: \" << context->getSelectedItem() << endl;\n context->setInsertedAmount(amount);\n context->setState(new HasMoneyState());\n }\n\n void dispenseItem(VendingMachine* context) override {\n cout << \"Insert coin before dispensing.\" << endl;\n }\n};\n```\n\n```go\ntype ItemSelectedState struct{}\n\nfunc (s *ItemSelectedState) SelectItem(context *VendingMachine, itemCode string) {\n\tfmt.Println(\"Item already selected: \" + context.GetSelectedItem())\n}\n\nfunc (s *ItemSelectedState) InsertCoin(context *VendingMachine, amount float64) {\n\tfmt.Println(\"Inserted $\" + strconv.FormatFloat(amount, 'f', -1, 64) + \" for item: \" + context.GetSelectedItem())\n\tcontext.SetInsertedAmount(amount)\n\tcontext.SetState(&HasMoneyState{})\n}\n\nfunc (s *ItemSelectedState) DispenseItem(context *VendingMachine) {\n\tfmt.Println(\"Insert coin before dispensing.\")\n}\n```\n\n```csharp\nclass ItemSelectedState : IMachineState\n{\n public void SelectItem(VendingMachine context, string itemCode)\n {\n Console.WriteLine(\"Item already selected: \" + context.GetSelectedItem());\n }\n\n public void InsertCoin(VendingMachine context, double amount)\n {\n Console.WriteLine(\"Inserted $\" + amount + \" for item: \" + context.GetSelectedItem());\n context.SetInsertedAmount(amount);\n context.SetState(new HasMoneyState());\n }\n\n public void DispenseItem(VendingMachine context)\n {\n Console.WriteLine(\"Insert coin before dispensing.\");\n }\n}\n```\n\n```typescript\nclass ItemSelectedState implements MachineState {\n selectItem(context: VendingMachine, itemCode: string): void {\n console.log(\"Item already selected: \" + context.getSelectedItem());\n }\n\n insertCoin(context: VendingMachine, amount: number): void {\n console.log(\"Inserted $\" + amount + \" for item: \" + context.getSelectedItem());\n context.setInsertedAmount(amount);\n context.setState(new HasMoneyState());\n }\n\n dispenseItem(context: VendingMachine): void {\n console.log(\"Insert coin before dispensing.\");\n }\n}\n```\n\n\n#### HasMoneyState\n\nMoney has been inserted. The machine is ready to dispense. Selecting a new item or inserting more money should be rejected.\n\n\n```java\nclass HasMoneyState implements MachineState {\n @Override\n public void selectItem(VendingMachine context, String itemCode) {\n System.out.println(\"Cannot change item after inserting money.\");\n }\n\n @Override\n public void insertCoin(VendingMachine context, double amount) {\n System.out.println(\"Money already inserted.\");\n }\n\n @Override\n public void dispenseItem(VendingMachine context) {\n System.out.println(\"Dispensing item: \" + context.getSelectedItem());\n context.setState(new DispensingState());\n System.out.println(\"Item dispensed successfully.\");\n context.reset();\n }\n}\n```\n\n```python\nclass HasMoneyState(MachineState):\n def select_item(self, context, item_code):\n print(\"Cannot change item after inserting money.\")\n\n def insert_coin(self, context, amount):\n print(\"Money already inserted.\")\n\n def dispense_item(self, context):\n print(f\"Dispensing item: {context.get_selected_item()}\")\n context.set_state(DispensingState())\n print(\"Item dispensed successfully.\")\n context.reset()\n```\n\n```cpp\nclass HasMoneyState : public MachineState {\npublic:\n void selectItem(VendingMachine* context, string itemCode) override {\n cout << \"Cannot change item after inserting money.\" << endl;\n }\n\n void insertCoin(VendingMachine* context, double amount) override {\n cout << \"Money already inserted.\" << endl;\n }\n\n void dispenseItem(VendingMachine* context) override {\n cout << \"Dispensing item: \" << context->getSelectedItem() << endl;\n context->setState(new DispensingState());\n cout << \"Item dispensed successfully.\" << endl;\n context->reset();\n }\n};\n```\n\n```go\ntype HasMoneyState struct{}\n\nfunc (s *HasMoneyState) SelectItem(context *VendingMachine, itemCode string) {\n\tfmt.Println(\"Cannot change item after inserting money.\")\n}\n\nfunc (s *HasMoneyState) InsertCoin(context *VendingMachine, amount float64) {\n\tfmt.Println(\"Money already inserted.\")\n}\n\nfunc (s *HasMoneyState) DispenseItem(context *VendingMachine) {\n\tfmt.Println(\"Dispensing item: \" + context.GetSelectedItem())\n\tcontext.SetState(&DispensingState{})\n\tfmt.Println(\"Item dispensed successfully.\")\n\tcontext.Reset()\n}\n```\n\n```csharp\nclass HasMoneyState : IMachineState\n{\n public void SelectItem(VendingMachine context, string itemCode)\n {\n Console.WriteLine(\"Cannot change item after inserting money.\");\n }\n\n public void InsertCoin(VendingMachine context, double amount)\n {\n Console.WriteLine(\"Money already inserted.\");\n }\n\n public void DispenseItem(VendingMachine context)\n {\n Console.WriteLine(\"Dispensing item: \" + context.GetSelectedItem());\n context.SetState(new DispensingState());\n Console.WriteLine(\"Item dispensed successfully.\");\n context.Reset();\n }\n}\n```\n\n```typescript\nclass HasMoneyState implements MachineState {\n selectItem(context: VendingMachine, itemCode: string): void {\n console.log(\"Cannot change item after inserting money.\");\n }\n\n insertCoin(context: VendingMachine, amount: number): void {\n console.log(\"Money already inserted.\");\n }\n\n dispenseItem(context: VendingMachine): void {\n console.log(\"Dispensing item: \" + context.getSelectedItem());\n context.setState(new DispensingState());\n console.log(\"Item dispensed successfully.\");\n context.reset();\n }\n}\n```\n\n\n#### DispensingState\n\nThe machine is actively dispensing. All actions should be rejected until dispensing completes.\n\n\n```java\nclass DispensingState implements MachineState {\n @Override\n public void selectItem(VendingMachine context, String itemCode) {\n System.out.println(\"Please wait, dispensing in progress.\");\n }\n\n @Override\n public void insertCoin(VendingMachine context, double amount) {\n System.out.println(\"Please wait, dispensing in progress.\");\n }\n\n @Override\n public void dispenseItem(VendingMachine context) {\n System.out.println(\"Already dispensing. Please wait.\");\n }\n}\n```\n\n```python\nclass DispensingState(MachineState):\n def select_item(self, context, item_code):\n print(\"Please wait, dispensing in progress.\")\n\n def insert_coin(self, context, amount):\n print(\"Please wait, dispensing in progress.\")\n\n def dispense_item(self, context):\n print(\"Already dispensing. Please wait.\")\n```\n\n```cpp\nclass DispensingState : public MachineState {\npublic:\n void selectItem(VendingMachine* context, string itemCode) override {\n cout << \"Please wait, dispensing in progress.\" << endl;\n }\n\n void insertCoin(VendingMachine* context, double amount) override {\n cout << \"Please wait, dispensing in progress.\" << endl;\n }\n\n void dispenseItem(VendingMachine* context) override {\n cout << \"Already dispensing. Please wait.\" << endl;\n }\n};\n```\n\n```go\ntype DispensingState struct{}\n\nfunc (d *DispensingState) selectItem(context *VendingMachine, itemCode string) {\n\tfmt.Println(\"Please wait, dispensing in progress.\")\n}\n\nfunc (d *DispensingState) insertCoin(context *VendingMachine, amount float64) {\n\tfmt.Println(\"Please wait, dispensing in progress.\")\n}\n\nfunc (d *DispensingState) dispenseItem(context *VendingMachine) {\n\tfmt.Println(\"Already dispensing. Please wait.\")\n}\n```\n\n```csharp\nclass DispensingState : IMachineState\n{\n public void SelectItem(VendingMachine context, string itemCode)\n {\n Console.WriteLine(\"Please wait, dispensing in progress.\");\n }\n\n public void InsertCoin(VendingMachine context, double amount)\n {\n Console.WriteLine(\"Please wait, dispensing in progress.\");\n }\n\n public void DispenseItem(VendingMachine context)\n {\n Console.WriteLine(\"Already dispensing. Please wait.\");\n }\n}\n```\n\n```typescript\nclass DispensingState implements MachineState {\n selectItem(context: VendingMachine, itemCode: string): void {\n console.log(\"Please wait, dispensing in progress.\");\n }\n\n insertCoin(context: VendingMachine, amount: number): void {\n console.log(\"Please wait, dispensing in progress.\");\n }\n\n dispenseItem(context: VendingMachine): void {\n console.log(\"Already dispensing. Please wait.\");\n }\n}\n```\n\n\n### Step 3: Implement the Context (VendingMachine)\n\nThe `VendingMachine` class (our context) maintains a reference to the current state and delegates all actions to it. It also holds the shared data that states need access to.\n\n\n```java\nclass VendingMachine {\n private MachineState currentState;\n private String selectedItem;\n private double insertedAmount;\n\n public VendingMachine() {\n this.currentState = new IdleState();\n }\n\n public void setState(MachineState newState) {\n this.currentState = newState;\n }\n\n public void setSelectedItem(String itemCode) {\n this.selectedItem = itemCode;\n }\n\n public void setInsertedAmount(double amount) {\n this.insertedAmount = amount;\n }\n\n public String getSelectedItem() {\n return selectedItem;\n }\n\n public void selectItem(String itemCode) {\n currentState.selectItem(this, itemCode);\n }\n\n public void insertCoin(double amount) {\n currentState.insertCoin(this, amount);\n }\n\n public void dispenseItem() {\n currentState.dispenseItem(this);\n }\n\n public void reset() {\n this.selectedItem = \"\";\n this.insertedAmount = 0.0;\n this.currentState = new IdleState();\n }\n}\n```\n\n```python\nclass VendingMachine:\n def __init__(self):\n self._current_state = IdleState()\n self._selected_item = \"\"\n self._inserted_amount = 0.0\n\n def set_state(self, new_state):\n self._current_state = new_state\n\n def set_selected_item(self, item_code):\n self._selected_item = item_code\n\n def set_inserted_amount(self, amount):\n self._inserted_amount = amount\n\n def get_selected_item(self):\n return self._selected_item\n\n def select_item(self, item_code):\n self._current_state.select_item(self, item_code)\n\n def insert_coin(self, amount):\n self._current_state.insert_coin(self, amount)\n\n def dispense_item(self):\n self._current_state.dispense_item(self)\n\n def reset(self):\n self._selected_item = \"\"\n self._inserted_amount = 0.0\n self._current_state = IdleState()\n```\n\n```cpp\nclass VendingMachine {\nprivate:\n MachineState* currentState;\n string selectedItem;\n double insertedAmount;\n\npublic:\n VendingMachine() : selectedItem(\"\"), insertedAmount(0.0) {\n currentState = new IdleState();\n }\n\n ~VendingMachine() {\n delete currentState;\n }\n\n void setState(MachineState* newState) {\n delete currentState;\n currentState = newState;\n }\n\n void setSelectedItem(string itemCode) {\n\t\tselectedItem = itemCode;\n\t}\n \n\tvoid setInsertedAmount(double amount) {\n\t\tinsertedAmount = amount;\n\t}\n \n\tstring getSelectedItem() {\n\t\treturn selectedItem;\n\t}\n\n void selectItem(string itemCode) {\n currentState->selectItem(this, itemCode);\n }\n\n void insertCoin(double amount) {\n currentState->insertCoin(this, amount);\n }\n\n void dispenseItem() {\n currentState->dispenseItem(this);\n }\n\n void reset() {\n selectedItem = \"\";\n insertedAmount = 0.0;\n setState(new IdleState());\n }\n};\n```\n\n```go\ntype VendingMachine struct {\n\tcurrentState MachineState\n\tselectedItem string\n\tinsertedAmount float64\n}\n\nfunc NewVendingMachine() *VendingMachine {\n\treturn &VendingMachine{currentState: IdleState{}}\n}\n\nfunc (v *VendingMachine) SetState(newState MachineState) {\n\tv.currentState = newState\n}\n\nfunc (v *VendingMachine) SetSelectedItem(itemCode string) {\n\tv.selectedItem = itemCode\n}\n\nfunc (v *VendingMachine) SetInsertedAmount(amount float64) {\n\tv.insertedAmount = amount\n}\n\nfunc (v *VendingMachine) GetSelectedItem() string {\n\treturn v.selectedItem\n}\n\nfunc (v *VendingMachine) SelectItem(itemCode string) {\n\tv.currentState.SelectItem(v, itemCode)\n}\n\nfunc (v *VendingMachine) InsertCoin(amount float64) {\n\tv.currentState.InsertCoin(v, amount)\n}\n\nfunc (v *VendingMachine) DispenseItem() {\n\tv.currentState.DispenseItem(v)\n}\n\nfunc (v *VendingMachine) Reset() {\n\tv.selectedItem = \"\"\n\tv.insertedAmount = 0.0\n\tv.currentState = IdleState{}\n}\n```\n\n```csharp\nclass VendingMachine\n{\n private IMachineState currentState;\n private string selectedItem = \"\";\n private double insertedAmount = 0.0;\n\n public VendingMachine()\n {\n currentState = new IdleState();\n }\n\n public void SetState(IMachineState newState) {\n\t\tcurrentState = newState;\n\t}\n\t\n public void SetSelectedItem(string itemCode) {\n\t\tselectedItem = itemCode;\n\t}\n\t\n public void SetInsertedAmount(double amount) {\n\t\tinsertedAmount = amount;\n\t}\n\t\n public string GetSelectedItem() {\n\t\treturn selectedItem;\n\t}\n\n public void SelectItem(string itemCode)\n {\n currentState.SelectItem(this, itemCode);\n }\n\n public void InsertCoin(double amount)\n {\n currentState.InsertCoin(this, amount);\n }\n\n public void DispenseItem()\n {\n currentState.DispenseItem(this);\n }\n\n public void Reset()\n {\n selectedItem = \"\";\n insertedAmount = 0.0;\n currentState = new IdleState();\n }\n}\n```\n\n```typescript\nclass VendingMachine {\n private currentState: MachineState;\n private selectedItem: string;\n private insertedAmount: number;\n\n constructor() {\n this.currentState = new IdleState(); // Initial state\n }\n\n setState(newState: MachineState): void {\n this.currentState = newState;\n }\n\n setSelectedItem(itemCode: string): void {\n this.selectedItem = itemCode;\n }\n\n setInsertedAmount(amount: number): void {\n this.insertedAmount = amount;\n }\n\n getSelectedItem(): string {\n return this.selectedItem;\n }\n\n selectItem(itemCode: string): void {\n this.currentState.selectItem(this, itemCode);\n }\n\n insertCoin(amount: number): void {\n this.currentState.insertCoin(this, amount);\n }\n\n dispenseItem(): void {\n this.currentState.dispenseItem(this);\n }\n\n reset(): void {\n this.selectedItem = \"\";\n this.insertedAmount = 0.0;\n this.currentState = new IdleState();\n }\n}\n```\n\n\n### Client code\n\n\n```java\npublic class VendingMachineApp {\n public static void main(String[] args) {\n VendingMachine vm = new VendingMachine();\n\n vm.insertCoin(1.0); // Rejected: no item selected\n vm.selectItem(\"A1\"); // Transitions to ItemSelectedState\n vm.insertCoin(1.5); // Transitions to HasMoneyState\n vm.dispenseItem(); // Dispenses, resets to IdleState\n\n System.out.println(\"\\n--- Second Transaction ---\");\n vm.selectItem(\"B2\");\n vm.insertCoin(2.0);\n vm.dispenseItem();\n }\n}\n```\n\n```python\ndef main():\n vm = VendingMachine()\n\n vm.insert_coin(1.0) # Rejected: no item selected\n vm.select_item(\"A1\") # Transitions to ItemSelectedState\n vm.insert_coin(1.5) # Transitions to HasMoneyState\n vm.dispense_item() # Dispenses, resets to IdleState\n\n print(\"\\n--- Second Transaction ---\")\n vm.select_item(\"B2\")\n vm.insert_coin(2.0)\n vm.dispense_item()\n\nif __name__ == \"__main__\":\n main()\n```\n\n```cpp\nint main() {\n VendingMachine* vm = new VendingMachine();\n\n vm->insertCoin(1.0); // Rejected: no item selected\n vm->selectItem(\"A1\"); // Transitions to ItemSelectedState\n vm->insertCoin(1.5); // Transitions to HasMoneyState\n vm->dispenseItem(); // Dispenses, resets to IdleState\n\n cout << \"\\n--- Second Transaction ---\" << endl;\n vm->selectItem(\"B2\");\n vm->insertCoin(2.0);\n vm->dispenseItem();\n\n delete vm;\n return 0;\n}\n```\n\n```go\nvm := NewVendingMachine()\n\nvm.InsertCoin(1.0) // Rejected: no item selected\nvm.SelectItem(\"A1\") // Transitions to ItemSelectedState\nvm.InsertCoin(1.5) // Transitions to HasMoneyState\nvm.DispenseItem() // Dispenses, resets to IdleState\n\nfmt.Println(\"\\n--- Second Transaction ---\")\nvm.SelectItem(\"B2\")\nvm.InsertCoin(2.0)\nvm.DispenseItem()\n```\n\n```csharp\npublic class Program\n{\n public static void Main(string[] args)\n {\n VendingMachine vm = new VendingMachine();\n\n vm.InsertCoin(1.0); // Rejected: no item selected\n vm.SelectItem(\"A1\"); // Transitions to ItemSelectedState\n vm.InsertCoin(1.5); // Transitions to HasMoneyState\n vm.DispenseItem(); // Dispenses, resets to IdleState\n\n Console.WriteLine(\"\\n--- Second Transaction ---\");\n vm.SelectItem(\"B2\");\n vm.InsertCoin(2.0);\n vm.DispenseItem();\n }\n}\n```\n\n```typescript\nconst vm = new VendingMachine();\n\nvm.insertCoin(1.0); // Rejected: no item selected\nvm.selectItem(\"A1\"); // Transitions to ItemSelectedState\nvm.insertCoin(1.5); // Transitions to HasMoneyState\nvm.dispenseItem(); // Dispenses, resets to IdleState\n\nconsole.log(\"\\n--- Second Transaction ---\");\nvm.selectItem(\"B2\");\nvm.insertCoin(2.0);\nvm.dispenseItem();\n```\n\n\nBy using the State pattern, we have transformed a rigid, condition-heavy implementation into a clean, flexible architecture where behaviors and transitions are clearly defined, decoupled, and easy to maintain. Adding a new state like `OutOfStockState` means creating one new class that implements `MachineState`. No existing state classes or the context need to change.\n\n---\n\n# 5. Practical Example: Document Workflow\n\nLet us work through a second example to reinforce the pattern. This time, we are building a document management system where documents move through a workflow: Draft, Under Review, and Published. Each state has different rules for what operations are allowed.\n\nIn Draft state, authors can edit the document and submit it for review. In Review state, reviewers can approve or reject it. In Published state, the document is read-only and can only be unpublished to go back to Draft.\n\n\n```mermaid\nstateDiagram-v2\n [*] --> DRAFT: Document created\n\n DRAFT --> UNDER_REVIEW: submitForReview()\n DRAFT --> DRAFT: edit() (allowed)\n\n UNDER_REVIEW --> PUBLISHED: approve()\n UNDER_REVIEW --> DRAFT: reject()\n UNDER_REVIEW --> UNDER_REVIEW: edit() (rejected)\n\n PUBLISHED --> DRAFT: unpublish()\n PUBLISHED --> PUBLISHED: edit() / approve() / reject()
(rejected)\n\n classDef draft fill:#ffd43b,stroke:#000,color:#000\n classDef review fill:#00ceff,stroke:#000,color:#000\n classDef published fill:#69db7c,stroke:#000,color:#000\n\n class DRAFT draft\n class UNDER_REVIEW review\n class PUBLISHED published\n```\n\n\n### Implementation\n\n\n```java\ninterface DocumentState {\n void edit(Document context, String content);\n void submitForReview(Document context);\n void approve(Document context);\n void reject(Document context);\n void unpublish(Document context);\n}\n\nclass DraftState implements DocumentState {\n @Override\n public void edit(Document context, String content) {\n System.out.println(\"Editing document: \" + content);\n context.setContent(content);\n }\n\n @Override\n public void submitForReview(Document context) {\n System.out.println(\"Document submitted for review.\");\n context.setState(new UnderReviewState());\n }\n\n @Override\n public void approve(Document context) {\n System.out.println(\"Cannot approve a draft. Submit for review first.\");\n }\n\n @Override\n public void reject(Document context) {\n System.out.println(\"Cannot reject a draft. Submit for review first.\");\n }\n\n @Override\n public void unpublish(Document context) {\n System.out.println(\"Document is already a draft.\");\n }\n}\n\nclass UnderReviewState implements DocumentState {\n @Override\n public void edit(Document context, String content) {\n System.out.println(\"Cannot edit while under review.\");\n }\n\n @Override\n public void submitForReview(Document context) {\n System.out.println(\"Document is already under review.\");\n }\n\n @Override\n public void approve(Document context) {\n System.out.println(\"Document approved and published.\");\n context.setState(new PublishedState());\n }\n\n @Override\n public void reject(Document context) {\n System.out.println(\"Document rejected. Returning to draft.\");\n context.setState(new DraftState());\n }\n\n @Override\n public void unpublish(Document context) {\n System.out.println(\"Document is not published yet.\");\n }\n}\n\nclass PublishedState implements DocumentState {\n @Override\n public void edit(Document context, String content) {\n System.out.println(\"Cannot edit a published document. Unpublish first.\");\n }\n\n @Override\n public void submitForReview(Document context) {\n System.out.println(\"Document is already published.\");\n }\n\n @Override\n public void approve(Document context) {\n System.out.println(\"Document is already published.\");\n }\n\n @Override\n public void reject(Document context) {\n System.out.println(\"Cannot reject a published document.\");\n }\n\n @Override\n public void unpublish(Document context) {\n System.out.println(\"Document unpublished. Returning to draft.\");\n context.setState(new DraftState());\n }\n}\n\nclass Document {\n private DocumentState currentState;\n private String content;\n\n public Document() {\n this.currentState = new DraftState();\n this.content = \"\";\n }\n\n public void setState(DocumentState state) { this.currentState = state; }\n public void setContent(String content) { this.content = content; }\n public String getContent() { return content; }\n\n public void edit(String content) { currentState.edit(this, content); }\n public void submitForReview() { currentState.submitForReview(this); }\n public void approve() { currentState.approve(this); }\n public void reject() { currentState.reject(this); }\n public void unpublish() { currentState.unpublish(this); }\n}\n\n// Usage\npublic class DocumentApp {\n public static void main(String[] args) {\n Document doc = new Document();\n\n doc.edit(\"First draft of the article.\");\n doc.approve(); // Rejected: cannot approve a draft\n doc.submitForReview();\n doc.edit(\"Trying to edit\"); // Rejected: under review\n doc.reject(); // Back to draft\n doc.edit(\"Revised draft.\");\n doc.submitForReview();\n doc.approve(); // Published\n doc.edit(\"Trying to edit\"); // Rejected: published\n doc.unpublish(); // Back to draft\n }\n}\n```\n\n```python\nfrom abc import ABC, abstractmethod\n\nclass DocumentState(ABC):\n @abstractmethod\n def edit(self, context, content):\n pass\n\n @abstractmethod\n def submit_for_review(self, context):\n pass\n\n @abstractmethod\n def approve(self, context):\n pass\n\n @abstractmethod\n def reject(self, context):\n pass\n\n @abstractmethod\n def unpublish(self, context):\n pass\n\nclass DraftState(DocumentState):\n def edit(self, context, content):\n print(f\"Editing document: {content}\")\n context.set_content(content)\n\n def submit_for_review(self, context):\n print(\"Document submitted for review.\")\n context.set_state(UnderReviewState())\n\n def approve(self, context):\n print(\"Cannot approve a draft. Submit for review first.\")\n\n def reject(self, context):\n print(\"Cannot reject a draft. Submit for review first.\")\n\n def unpublish(self, context):\n print(\"Document is already a draft.\")\n\nclass UnderReviewState(DocumentState):\n def edit(self, context, content):\n print(\"Cannot edit while under review.\")\n\n def submit_for_review(self, context):\n print(\"Document is already under review.\")\n\n def approve(self, context):\n print(\"Document approved and published.\")\n context.set_state(PublishedState())\n\n def reject(self, context):\n print(\"Document rejected. Returning to draft.\")\n context.set_state(DraftState())\n\n def unpublish(self, context):\n print(\"Document is not published yet.\")\n\nclass PublishedState(DocumentState):\n def edit(self, context, content):\n print(\"Cannot edit a published document. Unpublish first.\")\n\n def submit_for_review(self, context):\n print(\"Document is already published.\")\n\n def approve(self, context):\n print(\"Document is already published.\")\n\n def reject(self, context):\n print(\"Cannot reject a published document.\")\n\n def unpublish(self, context):\n print(\"Document unpublished. Returning to draft.\")\n context.set_state(DraftState())\n\nclass Document:\n def __init__(self):\n self._current_state = DraftState()\n self._content = \"\"\n\n def set_state(self, state):\n self._current_state = state\n\n def set_content(self, content):\n self._content = content\n\n def get_content(self):\n return self._content\n\n def edit(self, content):\n self._current_state.edit(self, content)\n\n def submit_for_review(self):\n self._current_state.submit_for_review(self)\n\n def approve(self):\n self._current_state.approve(self)\n\n def reject(self):\n self._current_state.reject(self)\n\n def unpublish(self):\n self._current_state.unpublish(self)\n\n# Usage\ndoc = Document()\n\ndoc.edit(\"First draft of the article.\")\ndoc.approve() # Rejected: cannot approve a draft\ndoc.submit_for_review()\ndoc.edit(\"Trying to edit\") # Rejected: under review\ndoc.reject() # Back to draft\ndoc.edit(\"Revised draft.\")\ndoc.submit_for_review()\ndoc.approve() # Published\ndoc.edit(\"Trying to edit\") # Rejected: published\ndoc.unpublish() # Back to draft\n```\n\n```cpp\n#include \n#include \n\nusing namespace std;\n\nclass Document; // Forward declaration\n\nclass DocumentState {\npublic:\n virtual ~DocumentState() = default;\n virtual void edit(Document* context, const string& content) = 0;\n virtual void submitForReview(Document* context) = 0;\n virtual void approve(Document* context) = 0;\n virtual void reject(Document* context) = 0;\n virtual void unpublish(Document* context) = 0;\n};\n\nclass DraftState : public DocumentState {\npublic:\n void edit(Document* context, const string& content) override;\n void submitForReview(Document* context) override;\n void approve(Document* context) override {\n cout << \"Cannot approve a draft. Submit for review first.\" << endl;\n }\n void reject(Document* context) override {\n cout << \"Cannot reject a draft. Submit for review first.\" << endl;\n }\n void unpublish(Document* context) override {\n cout << \"Document is already a draft.\" << endl;\n }\n};\n\nclass UnderReviewState : public DocumentState {\npublic:\n void edit(Document* context, const string& content) override {\n cout << \"Cannot edit while under review.\" << endl;\n }\n void submitForReview(Document* context) override {\n cout << \"Document is already under review.\" << endl;\n }\n void approve(Document* context) override;\n void reject(Document* context) override;\n void unpublish(Document* context) override {\n cout << \"Document is not published yet.\" << endl;\n }\n};\n\nclass PublishedState : public DocumentState {\npublic:\n void edit(Document* context, const string& content) override {\n cout << \"Cannot edit a published document. Unpublish first.\" << endl;\n }\n void submitForReview(Document* context) override {\n cout << \"Document is already published.\" << endl;\n }\n void approve(Document* context) override {\n cout << \"Document is already published.\" << endl;\n }\n void reject(Document* context) override {\n cout << \"Cannot reject a published document.\" << endl;\n }\n void unpublish(Document* context) override;\n};\n\nclass Document {\nprivate:\n DocumentState* currentState;\n string content;\n\npublic:\n Document() : currentState(new DraftState()), content(\"\") {}\n ~Document() { delete currentState; }\n\n void setState(DocumentState* state) {\n delete currentState;\n currentState = state;\n }\n\n void setContent(const string& c) { content = c; }\n string getContent() const { return content; }\n\n void edit(const string& c) { currentState->edit(this, c); }\n void submitForReview() { currentState->submitForReview(this); }\n void approve() { currentState->approve(this); }\n void reject() { currentState->reject(this); }\n void unpublish() { currentState->unpublish(this); }\n};\n\n// Deferred implementations\nvoid DraftState::edit(Document* context, const string& content) {\n cout << \"Editing document: \" << content << endl;\n context->setContent(content);\n}\n\nvoid DraftState::submitForReview(Document* context) {\n cout << \"Document submitted for review.\" << endl;\n context->setState(new UnderReviewState());\n}\n\nvoid UnderReviewState::approve(Document* context) {\n cout << \"Document approved and published.\" << endl;\n context->setState(new PublishedState());\n}\n\nvoid UnderReviewState::reject(Document* context) {\n cout << \"Document rejected. Returning to draft.\" << endl;\n context->setState(new DraftState());\n}\n\nvoid PublishedState::unpublish(Document* context) {\n cout << \"Document unpublished. Returning to draft.\" << endl;\n context->setState(new DraftState());\n}\n\n// Usage (matches your Java flow)\nint main() {\n Document doc;\n\n doc.edit(\"First draft of the article.\");\n doc.approve(); // Cannot approve a draft\n doc.submitForReview();\n doc.edit(\"Trying to edit\"); // Cannot edit while under review\n doc.reject(); // Back to draft\n doc.edit(\"Revised draft.\");\n doc.submitForReview();\n doc.approve(); // Published\n doc.edit(\"Trying to edit\"); // Cannot edit a published document\n doc.unpublish(); // Back to draft\n\n return 0;\n}\n```\n\n```go\npackage main\n\nimport \"fmt\"\n\ntype DocumentState interface {\n\tedit(context *Document, content string)\n\tsubmitForReview(context *Document)\n\tapprove(context *Document)\n\treject(context *Document)\n\tunpublish(context *Document)\n}\n\ntype DraftState struct{}\n\nfunc (d *DraftState) edit(context *Document, content string) {\n\tfmt.Println(\"Editing document: \" + content)\n\tcontext.setContent(content)\n}\n\nfunc (d *DraftState) submitForReview(context *Document) {\n\tfmt.Println(\"Document submitted for review.\")\n\tcontext.setState(&UnderReviewState{})\n}\n\nfunc (d *DraftState) approve(context *Document) {\n\tfmt.Println(\"Cannot approve a draft. Submit for review first.\")\n}\n\nfunc (d *DraftState) reject(context *Document) {\n\tfmt.Println(\"Cannot reject a draft. Submit for review first.\")\n}\n\nfunc (d *DraftState) unpublish(context *Document) {\n\tfmt.Println(\"Document is already a draft.\")\n}\n\ntype UnderReviewState struct{}\n\nfunc (u *UnderReviewState) edit(context *Document, content string) {\n\tfmt.Println(\"Cannot edit while under review.\")\n}\n\nfunc (u *UnderReviewState) submitForReview(context *Document) {\n\tfmt.Println(\"Document is already under review.\")\n}\n\nfunc (u *UnderReviewState) approve(context *Document) {\n\tfmt.Println(\"Document approved and published.\")\n\tcontext.setState(&PublishedState{})\n}\n\nfunc (u *UnderReviewState) reject(context *Document) {\n\tfmt.Println(\"Document rejected. Returning to draft.\")\n\tcontext.setState(&DraftState{})\n}\n\nfunc (u *UnderReviewState) unpublish(context *Document) {\n\tfmt.Println(\"Document is not published yet.\")\n}\n\ntype PublishedState struct{}\n\nfunc (p *PublishedState) edit(context *Document, content string) {\n\tfmt.Println(\"Cannot edit a published document. Unpublish first.\")\n}\n\nfunc (p *PublishedState) submitForReview(context *Document) {\n\tfmt.Println(\"Document is already published.\")\n}\n\nfunc (p *PublishedState) approve(context *Document) {\n\tfmt.Println(\"Document is already published.\")\n}\n\nfunc (p *PublishedState) reject(context *Document) {\n\tfmt.Println(\"Cannot reject a published document.\")\n}\n\nfunc (p *PublishedState) unpublish(context *Document) {\n\tfmt.Println(\"Document unpublished. Returning to draft.\")\n\tcontext.setState(&DraftState{})\n}\n\ntype Document struct {\n\tcurrentState DocumentState\n\tcontent string\n}\n\nfunc NewDocument() *Document {\n\treturn &Document{currentState: &DraftState{}, content: \"\"}\n}\n\nfunc (d *Document) setState(state DocumentState) { d.currentState = state }\nfunc (d *Document) setContent(content string) { d.content = content }\nfunc (d *Document) getContent() string { return d.content }\n\nfunc (d *Document) edit(content string) { d.currentState.edit(d, content) }\nfunc (d *Document) submitForReview() { d.currentState.submitForReview(d) }\nfunc (d *Document) approve() { d.currentState.approve(d) }\nfunc (d *Document) reject() { d.currentState.reject(d) }\nfunc (d *Document) unpublish() { d.currentState.unpublish(d) }\n\nfunc main() {\n\tdoc := NewDocument()\n\n\tdoc.edit(\"First draft of the article.\")\n\tdoc.approve()\n\tdoc.submitForReview()\n\tdoc.edit(\"Trying to edit\")\n\tdoc.reject()\n\tdoc.edit(\"Revised draft.\")\n\tdoc.submitForReview()\n\tdoc.approve()\n\tdoc.edit(\"Trying to edit\")\n\tdoc.unpublish()\n}\n```\n\n```csharp\nusing System;\n\ninterface IDocumentState\n{\n void Edit(Document context, string content);\n void SubmitForReview(Document context);\n void Approve(Document context);\n void Reject(Document context);\n void Unpublish(Document context);\n}\n\nclass DraftState : IDocumentState\n{\n public void Edit(Document context, string content)\n {\n Console.WriteLine(\"Editing document: \" + content);\n context.SetContent(content);\n }\n\n public void SubmitForReview(Document context)\n {\n Console.WriteLine(\"Document submitted for review.\");\n context.SetState(new UnderReviewState());\n }\n\n public void Approve(Document context)\n {\n Console.WriteLine(\"Cannot approve a draft. Submit for review first.\");\n }\n\n public void Reject(Document context)\n {\n Console.WriteLine(\"Cannot reject a draft. Submit for review first.\");\n }\n\n public void Unpublish(Document context)\n {\n Console.WriteLine(\"Document is already a draft.\");\n }\n}\n\nclass UnderReviewState : IDocumentState\n{\n public void Edit(Document context, string content)\n {\n Console.WriteLine(\"Cannot edit while under review.\");\n }\n\n public void SubmitForReview(Document context)\n {\n Console.WriteLine(\"Document is already under review.\");\n }\n\n public void Approve(Document context)\n {\n Console.WriteLine(\"Document approved and published.\");\n context.SetState(new PublishedState());\n }\n\n public void Reject(Document context)\n {\n Console.WriteLine(\"Document rejected. Returning to draft.\");\n context.SetState(new DraftState());\n }\n\n public void Unpublish(Document context)\n {\n Console.WriteLine(\"Document is not published yet.\");\n }\n}\n\nclass PublishedState : IDocumentState\n{\n public void Edit(Document context, string content)\n {\n Console.WriteLine(\"Cannot edit a published document. Unpublish first.\");\n }\n\n public void SubmitForReview(Document context)\n {\n Console.WriteLine(\"Document is already published.\");\n }\n\n public void Approve(Document context)\n {\n Console.WriteLine(\"Document is already published.\");\n }\n\n public void Reject(Document context)\n {\n Console.WriteLine(\"Cannot reject a published document.\");\n }\n\n public void Unpublish(Document context)\n {\n Console.WriteLine(\"Document unpublished. Returning to draft.\");\n context.SetState(new DraftState());\n }\n}\n\nclass Document\n{\n private IDocumentState currentState;\n private string content = \"\";\n\n public Document() { currentState = new DraftState(); }\n\n public void SetState(IDocumentState state) { currentState = state; }\n public void SetContent(string content) { this.content = content; }\n public string GetContent() { return content; }\n\n public void Edit(string content) { currentState.Edit(this, content); }\n public void SubmitForReview() { currentState.SubmitForReview(this); }\n public void Approve() { currentState.Approve(this); }\n public void Reject() { currentState.Reject(this); }\n public void Unpublish() { currentState.Unpublish(this); }\n}\n\n// Usage\nclass Program\n{\n static void Main(string[] args)\n {\n Document doc = new Document();\n\n doc.Edit(\"First draft of the article.\");\n doc.Approve(); // Rejected: cannot approve a draft\n doc.SubmitForReview();\n doc.Edit(\"Trying to edit\"); // Rejected: under review\n doc.Reject(); // Back to draft\n doc.Edit(\"Revised draft.\");\n doc.SubmitForReview();\n doc.Approve(); // Published\n doc.Edit(\"Trying to edit\"); // Rejected: published\n doc.Unpublish(); // Back to draft\n }\n}\n```\n\n```typescript\ninterface DocumentState {\n edit(context: Document, content: string): void;\n submitForReview(context: Document): void;\n approve(context: Document): void;\n reject(context: Document): void;\n unpublish(context: Document): void;\n}\n\nclass DraftState implements DocumentState {\n edit(context: Document, content: string): void {\n console.log(\"Editing document: \" + content);\n context.setContent(content);\n }\n\n submitForReview(context: Document): void {\n console.log(\"Document submitted for review.\");\n context.setState(new UnderReviewState());\n }\n\n approve(context: Document): void {\n console.log(\"Cannot approve a draft. Submit for review first.\");\n }\n\n reject(context: Document): void {\n console.log(\"Cannot reject a draft. Submit for review first.\");\n }\n\n unpublish(context: Document): void {\n console.log(\"Document is already a draft.\");\n }\n}\n\nclass UnderReviewState implements DocumentState {\n edit(context: Document, content: string): void {\n console.log(\"Cannot edit while under review.\");\n }\n\n submitForReview(context: Document): void {\n console.log(\"Document is already under review.\");\n }\n\n approve(context: Document): void {\n console.log(\"Document approved and published.\");\n context.setState(new PublishedState());\n }\n\n reject(context: Document): void {\n console.log(\"Document rejected. Returning to draft.\");\n context.setState(new DraftState());\n }\n\n unpublish(context: Document): void {\n console.log(\"Document is not published yet.\");\n }\n}\n\nclass PublishedState implements DocumentState {\n edit(context: Document, content: string): void {\n console.log(\"Cannot edit a published document. Unpublish first.\");\n }\n\n submitForReview(context: Document): void {\n console.log(\"Document is already published.\");\n }\n\n approve(context: Document): void {\n console.log(\"Document is already published.\");\n }\n\n reject(context: Document): void {\n console.log(\"Cannot reject a published document.\");\n }\n\n unpublish(context: Document): void {\n console.log(\"Document unpublished. Returning to draft.\");\n context.setState(new DraftState());\n }\n}\n\nclass Document {\n private currentState: DocumentState;\n private content: string = \"\";\n\n constructor() { this.currentState = new DraftState(); }\n\n setState(state: DocumentState): void { this.currentState = state; }\n setContent(content: string): void { this.content = content; }\n getContent(): string { return this.content; }\n\n edit(content: string): void { this.currentState.edit(this, content); }\n submitForReview(): void { this.currentState.submitForReview(this); }\n approve(): void { this.currentState.approve(this); }\n reject(): void { this.currentState.reject(this); }\n unpublish(): void { this.currentState.unpublish(this); }\n}\n\n// Usage\nconst doc = new Document();\n\ndoc.edit(\"First draft of the article.\");\ndoc.approve(); // Rejected: cannot approve a draft\ndoc.submitForReview();\ndoc.edit(\"Trying to edit\"); // Rejected: under review\ndoc.reject(); // Back to draft\ndoc.edit(\"Revised draft.\");\ndoc.submitForReview();\ndoc.approve(); // Published\ndoc.edit(\"Trying to edit\"); // Rejected: published\ndoc.unpublish(); // Back to draft\n```\n\n\nThis example reinforces the same principles as the vending machine but in a different domain. Notice how each state cleanly defines what is allowed and what is not, and how transitions are handled by the states themselves. Adding a new state like `ArchivedState` would mean creating one new class without touching any existing code.","pageType":"lld-interviews"}

Get Premium