Iterator, Mediator, and Memento Patterns (GoF Behavioral Patterns)

This page covers the tail end of the Iterator pattern (internal iterators, known uses, and related patterns), the complete Mediator pattern, and most of the Memento pattern. These are behavioral patterns from the Gang of Four catalog concerned with managing object communication, state capture, and traversal.

Key Concepts

Iterator (conclusion)

• Internal iterators can encapsulate different iteration strategies (e.g., FilteringListTraverser adds a TestItem predicate to control which elements are processed)
• Internal iterator Traverse uses Template Method — TestItem and ProcessItem are primitive operations overridden by subclasses
• Smalltalk collections use do: with blocks (closures) as internal iterators; ReadStream serves as an external iterator for sequential collections
• No standard external iterators exist for non-sequential Smalltalk collections (Set, Dictionary)

Mediator

• Intent: Define an object that encapsulates how a set of objects interact; promotes loose coupling by preventing direct references between colleagues
• Replaces many-to-many interactions with one-to-many (mediator-to-colleagues), which are easier to understand and maintain
• Colleagues only know the mediator, not each other — all communication routes through the mediator
• Trades interaction complexity for mediator complexity — the mediator can become a monolith
• The abstract Mediator class can be omitted when colleagues only work with one mediator
• Colleague-Mediator communication can use Observer pattern (colleagues as Subjects) or a specialized notification interface where the colleague passes itself as an argument

Memento

• Intent: Capture and externalize an object's internal state without violating encapsulation, so the object can be restored later
• Also known as Token
• Three participants: Originator (creates/restores from memento), Memento (stores state), Caretaker (safekeeps memento without examining contents)
• Memento has two interfaces: narrow (public, for caretaker — pass-through only) and wide (private, for originator — full state access)
• Mementos are passive — only the originator assigns or retrieves state
• Incremental mementos: when created in predictable sequence, can store only the delta rather than full state

Commands and Syntax

Mediator — FontDialogDirector example (C++)

class DialogDirector {
public:
    virtual void ShowDialog();
    virtual void WidgetChanged(Widget*) = 0;
protected:
    virtual void CreateWidgets() = 0;
};

class Widget {
public:
    Widget(DialogDirector*);
    virtual void Changed();  // calls _director->WidgetChanged(this)
private:
    DialogDirector* _director;
};

• WidgetChanged uses identity checks (if (theChangedWidget == _fontList)) to dispatch behavior per widget

Memento — C++ friend idiom for dual interfaces

class Memento {
public:
    virtual ~Memento();          // narrow public interface
private:
    friend class Originator;     // wide interface via friend
    Memento();
    void SetState(State*);
    State* GetState();
};

Memento — Command integration for undo

void MoveCommand::Execute() {
    _state = solver->CreateMemento();  // checkpoint before action
    _target->Move(_delta);
    solver->Solve();
}
void MoveCommand::Unexecute() {
    _target->Move(-_delta);
    solver->SetMemento(_state);        // restore previous state
    solver->Solve();
}

Relationships

• Iterator relates to: Composite (recursive traversal), Factory Method (polymorphic iterator creation), Memento (capturing iteration state)
• Mediator vs. Facade: Facade is unidirectional (client → subsystem); Mediator is multidirectional (colleagues ↔ mediator). Facade simplifies an interface; Mediator enables cooperative behavior
• Mediator + Observer: Colleagues can communicate with their mediator using the Observer pattern
• Memento + Command: Commands use mementos to store pre-execution state for undo; MoveCommand stores a ConstraintSolverMemento
• Memento + Iterator: Iterators can use mementos to capture iteration state (Dylan's "state objects")
• ConstraintSolver as Singleton: The Memento example uses Singleton for the constraint solver

Exam-Relevant Points

• Mediator replaces many-to-many with one-to-many — this is the core structural transformation
• Mediator's key tradeoff: centralizes control but risks becoming a monolith
• The abstract Mediator class is optional when only one concrete mediator exists
• Memento's two interfaces (narrow for caretaker, wide for originator) are enforced in C++ via friend class
• Caretakers never examine or operate on memento contents — they are opaque
• Mementos can store incremental changes when created in predictable sequences (e.g., undo history)
• Memento preserves encapsulation — the key differentiator from simply exposing state via getters
• Hidden cost: caretakers don't know memento size, so lightweight caretakers may unknowingly incur large storage costs
• Mediator's WidgetChanged uses the colleague reference to identify the sender — the Smalltalk/V delegation approach
• Dylan collections use memento-like "state objects" for iteration — connecting Memento to Iterator