Mediator and Memento.

# room_v1.py: four widgets that call each other, so every new rule edits several of them
class Cart:
    def __init__(self):
        self.items, self.locked, self.banner = [], False, None

    def add(self, name, price):
        if self.locked:
            raise ValueError("the cart is locked")
        self.items.append((name, price))
        self.banner.refresh()

    def total(self):
        return sum(price for _, price in self.items)


class Roster:
    def __init__(self):
        self.names, self.cart, self.banner = [], None, None

    def join(self, name):
        if self.cart.locked:
            raise ValueError("the cart is locked")
        self.names.append(name)
        self.banner.refresh()


class PayDesk:
    def __init__(self):
        self.shares, self.paid, self.cart, self.roster, self.banner = {}, [], None, None, None

    def lock(self):
        total, count = self.cart.total(), len(self.roster.names)
        base, extra = divmod(total, count)
        for i, name in enumerate(self.roster.names):
            self.shares[name] = base + (1 if i < extra else 0)
        self.cart.locked = True
        self.banner.refresh()

    def pay(self, name):
        if not self.cart.locked:
            raise ValueError("lock the cart first")
        self.paid.append(name)
        self.banner.refresh()
        return self.shares[name]


class Banner:
    def __init__(self):
        self.text, self.cart, self.roster, self.desk = "", None, None, None

    def refresh(self):
        total, count = self.cart.total(), len(self.roster.names)
        if not self.cart.locked:
            self.text = f"open: {count} members, {len(self.cart.items)} items, total {total}"
        elif len(self.desk.paid) == count:
            self.text = f"placed: total {total}, paid by {count}"
        else:
            self.text = f"locked: total {total}, {len(self.desk.paid)} of {count} paid"


cart, roster, desk, banner = Cart(), Roster(), PayDesk(), Banner()
cart.banner = banner  # the wiring: nine references among four classes
roster.cart, roster.banner = cart, banner
desk.cart, desk.roster, desk.banner = cart, roster, banner
banner.cart, banner.roster, banner.desk = cart, roster, desk

for who in ["Asha", "Ben", "Chitra"]:
    roster.join(who)
for item, price in [("biryani", 250), ("paneer", 180), ("lassi", 60)]:
    cart.add(item, price)
print(banner.text)
try:
    desk.pay("Asha")
except ValueError as e:
    print("pay before lock: refused (" + str(e) + ")")
desk.lock()
print(banner.text)

// RoomV1.java: four widgets that call each other, so every new rule edits several of them
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

class RoomV1 {
    record Item(String name, int price) {}

    static final class Cart {
        final List<Item> items = new ArrayList<>();
        boolean locked;
        Banner banner;

        void add(String name, int price) {
            if (locked) throw new IllegalStateException("the cart is locked");
            items.add(new Item(name, price));
            banner.refresh();
        }

        int total() { return items.stream().mapToInt(Item::price).sum(); }
    }

    static final class Roster {
        final List<String> names = new ArrayList<>();
        Cart cart;
        Banner banner;

        void join(String name) {
            if (cart.locked) throw new IllegalStateException("the cart is locked");
            names.add(name);
            banner.refresh();
        }
    }

    static final class PayDesk {
        final Map<String, Integer> shares = new LinkedHashMap<>();
        final List<String> paid = new ArrayList<>();
        Cart cart;
        Roster roster;
        Banner banner;

        void lock() {
            int total = cart.total(), count = roster.names.size();
            int base = total / count, extra = total % count;
            for (int i = 0; i < count; i++) shares.put(roster.names.get(i), base + (i < extra ? 1 : 0));
            cart.locked = true;
            banner.refresh();
        }

        int pay(String name) {
            if (!cart.locked) throw new IllegalStateException("lock the cart first");
            paid.add(name);
            banner.refresh();
            return shares.get(name);
        }
    }

    static final class Banner {
        String text = "";
        Cart cart;
        Roster roster;
        PayDesk desk;

        void refresh() {
            int total = cart.total(), count = roster.names.size();
            if (!cart.locked) text = "open: " + count + " members, " + cart.items.size() + " items, total " + total;
            else if (desk.paid.size() == count) text = "placed: total " + total + ", paid by " + count;
            else text = "locked: total " + total + ", " + desk.paid.size() + " of " + count + " paid";
        }
    }

    public static void main(String[] args) {
        Cart cart = new Cart();
        Roster roster = new Roster();
        PayDesk desk = new PayDesk();
        Banner banner = new Banner();
        cart.banner = banner; // the wiring: nine references among four classes
        roster.cart = cart; roster.banner = banner;
        desk.cart = cart; desk.roster = roster; desk.banner = banner;
        banner.cart = cart; banner.roster = roster; banner.desk = desk;

        for (String who : List.of("Asha", "Ben", "Chitra")) roster.join(who);
        cart.add("biryani", 250);
        cart.add("paneer", 180);
        cart.add("lassi", 60);
        System.out.println(banner.text);
        try {
            desk.pay("Asha");
        } catch (IllegalStateException e) {
            System.out.println("pay before lock: refused (" + e.getMessage() + ")");
        }
        desk.lock();
        System.out.println(banner.text);
    }
}

// room_v1.cpp: four widgets that call each other, so every new rule edits several of them
#include <iostream>
#include <map>
#include <numeric>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>

struct Banner;

struct Cart {
    std::vector<std::pair<std::string, int>> items;
    bool locked = false;
    Banner* banner = nullptr;

    void add(const std::string& name, int price);
    int total() const {
        return std::accumulate(items.begin(), items.end(), 0, [](int sum, const auto& item) { return sum + item.second; });
    }
};

struct Roster {
    std::vector<std::string> names;
    Cart* cart = nullptr;
    Banner* banner = nullptr;

    void join(const std::string& name);
};

struct PayDesk {
    std::map<std::string, int> shares;
    std::vector<std::string> paid;
    Cart* cart = nullptr;
    Roster* roster = nullptr;
    Banner* banner = nullptr;

    void lock();
    int pay(const std::string& name);
};

struct Banner {
    std::string text;
    Cart* cart = nullptr;
    Roster* roster = nullptr;
    PayDesk* desk = nullptr;

    void refresh() {
        int total = cart->total(), count = static_cast<int>(roster->names.size());
        if (!cart->locked) {
            text = "open: " + std::to_string(count) + " members, " + std::to_string(cart->items.size()) + " items, total " + std::to_string(total);
        } else if (static_cast<int>(desk->paid.size()) == count) {
            text = "placed: total " + std::to_string(total) + ", paid by " + std::to_string(count);
        } else {
            text = "locked: total " + std::to_string(total) + ", " + std::to_string(desk->paid.size()) + " of " + std::to_string(count) + " paid";
        }
    }
};

void Cart::add(const std::string& name, int price) {
    if (locked) throw std::runtime_error("the cart is locked");
    items.emplace_back(name, price);
    banner->refresh();
}

void Roster::join(const std::string& name) {
    if (cart->locked) throw std::runtime_error("the cart is locked");
    names.push_back(name);
    banner->refresh();
}

void PayDesk::lock() {
    int total = cart->total(), count = static_cast<int>(roster->names.size());
    int base = total / count, extra = total % count;
    for (int i = 0; i < count; i++) shares[roster->names[i]] = base + (i < extra ? 1 : 0);
    cart->locked = true;
    banner->refresh();
}

int PayDesk::pay(const std::string& name) {
    if (!cart->locked) throw std::runtime_error("lock the cart first");
    paid.push_back(name);
    banner->refresh();
    return shares[name];
}

int main() {
    Cart cart;
    Roster roster;
    PayDesk desk;
    Banner banner;
    cart.banner = &banner;  // the wiring: nine references among four classes
    roster.cart = &cart; roster.banner = &banner;
    desk.cart = &cart; desk.roster = &roster; desk.banner = &banner;
    banner.cart = &cart; banner.roster = &roster; banner.desk = &desk;

    for (const char* who : {"Asha", "Ben", "Chitra"}) roster.join(who);
    cart.add("biryani", 250);
    cart.add("paneer", 180);
    cart.add("lassi", 60);
    std::cout << banner.text << "\n";
    try {
        desk.pay("Asha");
    } catch (const std::runtime_error& e) {
        std::cout << "pay before lock: refused (" << e.what() << ")\n";
    }
    desk.lock();
    std::cout << banner.text << "\n";
}

// room_v1.js: four widgets that call each other, so every new rule edits several of them
class Cart {
  constructor() {
    Object.assign(this, { items: [], locked: false, banner: null });
  }
  add(name, price) {
    if (this.locked) throw new Error("the cart is locked");
    this.items.push({ name, price });
    this.banner.refresh();
  }
  total() {
    return this.items.reduce((sum, item) => sum + item.price, 0);
  }
}

class Roster {
  constructor() {
    Object.assign(this, { names: [], cart: null, banner: null });
  }
  join(name) {
    if (this.cart.locked) throw new Error("the cart is locked");
    this.names.push(name);
    this.banner.refresh();
  }
}

class PayDesk {
  constructor() {
    Object.assign(this, { shares: {}, paid: [], cart: null, roster: null, banner: null });
  }
  lock() {
    const total = this.cart.total();
    const count = this.roster.names.length;
    const base = Math.floor(total / count);
    const extra = total % count;
    this.roster.names.forEach((name, i) => {
      this.shares[name] = base + (i < extra ? 1 : 0);
    });
    this.cart.locked = true;
    this.banner.refresh();
  }
  pay(name) {
    if (!this.cart.locked) throw new Error("lock the cart first");
    this.paid.push(name);
    this.banner.refresh();
    return this.shares[name];
  }
}

class Banner {
  constructor() {
    Object.assign(this, { text: "", cart: null, roster: null, desk: null });
  }
  refresh() {
    const total = this.cart.total();
    const count = this.roster.names.length;
    if (!this.cart.locked) this.text = `open: ${count} members, ${this.cart.items.length} items, total ${total}`;
    else if (this.desk.paid.length === count) this.text = `placed: total ${total}, paid by ${count}`;
    else this.text = `locked: total ${total}, ${this.desk.paid.length} of ${count} paid`;
  }
}

const cart = new Cart();
const roster = new Roster();
const desk = new PayDesk();
const banner = new Banner();
cart.banner = banner; // the wiring: nine references among four classes
Object.assign(roster, { cart, banner });
Object.assign(desk, { cart, roster, banner });
Object.assign(banner, { cart, roster, desk });

for (const who of ["Asha", "Ben", "Chitra"]) roster.join(who);
for (const [item, price] of [["biryani", 250], ["paneer", 180], ["lassi", 60]]) cart.add(item, price);
console.log(banner.text);
try {
  desk.pay("Asha");
} catch (e) {
  console.log(`pay before lock: refused (${e.message})`);
}
desk.lock();
console.log(banner.text);

# group_room.py: the room is the only class that knows all the others
from abc import ABC, abstractmethod


class Mediator(ABC):
    """What a colleague knows about the room: how to tell it that something happened."""

    @abstractmethod
    def notify(self, sender: str, event: str, name: str = "", amount: int = 0) -> None: ...


class Cart:
    def __init__(self, room: Mediator) -> None:
        self.room, self.items = room, []

    def add(self, name, price):  # a user action: tell the room, change nothing here
        self.room.notify("cart", "add", name, price)

    def put(self, name, price):  # what the room asks the cart to do
        self.items.append((name, price))

    def total(self):
        return sum(price for _, price in self.items)


class Roster:
    def __init__(self, room: Mediator) -> None:
        self.room, self.names = room, []

    def join(self, name):
        self.room.notify("roster", "join", name)

    def admit(self, name):
        self.names.append(name)


class PayDesk:
    def __init__(self, room: Mediator) -> None:
        self.room, self.shares, self.paid = room, {}, []

    def lock(self):
        self.room.notify("desk", "lock")

    def pay(self, name):
        self.room.notify("desk", "pay", name)
        return self.shares[name]

    def split(self, total, names):  # equal shares; the first few members cover the remainder
        base, extra = divmod(total, len(names))
        self.shares = {n: base + (1 if i < extra else 0) for i, n in enumerate(names)}


class Banner:
    def __init__(self) -> None:
        self.text = ""

    def show(self, text):
        self.text = text


class Room(Mediator):
    """The mediator: every rule about how the parts affect each other lives here."""

    def __init__(self) -> None:
        self.cart, self.roster = Cart(self), Roster(self)
        self.desk, self.banner = PayDesk(self), Banner()
        self.locked, self.heard = False, {}  # events heard, by sender
        self._rules = {"add": self._add, "join": self._join, "lock": self._lock, "pay": self._pay}

    def notify(self, sender, event, name="", amount=0):
        self._rules[event](name, amount)
        self.heard[sender] = self.heard.get(sender, 0) + 1  # counted only when the rule did not refuse
        self.banner.show(self._summary())

    def _add(self, name, amount):
        if self.locked:
            raise ValueError("the cart is locked")
        self.cart.put(name, amount)

    def _join(self, name, amount):
        if self.locked:
            raise ValueError("the cart is locked")
        self.roster.admit(name)

    def _lock(self, name, amount):
        if not self.roster.names:
            raise ValueError("nobody has joined")
        self.desk.split(self.cart.total(), self.roster.names)
        self.locked = True

    def _pay(self, name, amount):
        if not self.locked:
            raise ValueError("lock the cart first")
        self.desk.paid.append(name)

    def _summary(self):
        total, count = self.cart.total(), len(self.roster.names)
        if not self.locked:
            return f"open: {count} members, {len(self.cart.items)} items, total {total}"
        if len(self.desk.paid) == count:
            return f"placed: total {total}, paid by {count}"
        return f"locked: total {total}, {len(self.desk.paid)} of {count} paid"


def attempt(label, action):
    try:
        action()
    except ValueError as e:
        print(f"{label}: refused ({e})")


room = Room()
for who in ["Asha", "Ben", "Chitra"]:
    room.roster.join(who)
for item, price in [("biryani", 250), ("paneer", 180), ("lassi", 60)]:
    room.cart.add(item, price)
print(room.banner.text)
attempt("pay before lock", lambda: room.desk.pay("Asha"))
room.desk.lock()
print("shares: " + ", ".join(f"{n} {room.desk.shares[n]}" for n in room.roster.names))
attempt("add after lock", lambda: room.cart.add("naan", 40))
attempt("join after lock", lambda: room.roster.join("Dev"))
for who in ["Asha", "Ben"]:
    print(f"{who} pays {room.desk.pay(who)}")
print(room.banner.text)
print(f"Chitra pays {room.desk.pay('Chitra')}")
print(room.banner.text)
print("events through the room:", ", ".join(f"{k} {v}" for k, v in sorted(room.heard.items())))

// GroupRoom.java: the room is the only class that knows all the others
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

class GroupRoom {
    record Item(String name, int price) {}

    /** What a colleague knows about the room: how to tell it that something happened. */
    interface Mediator {
        void notify(String sender, String event, String name, int amount);
    }

    static final class Cart {
        private final Mediator room;
        final List<Item> items = new ArrayList<>();

        Cart(Mediator room) { this.room = room; }

        void add(String name, int price) { room.notify("cart", "add", name, price); } // a user action: tell the room
        void put(String name, int price) { items.add(new Item(name, price)); }        // what the room asks for
        int total() { return items.stream().mapToInt(Item::price).sum(); }
    }

    static final class Roster {
        private final Mediator room;
        final List<String> names = new ArrayList<>();

        Roster(Mediator room) { this.room = room; }

        void join(String name) { room.notify("roster", "join", name, 0); }
        void admit(String name) { names.add(name); }
    }

    static final class PayDesk {
        private final Mediator room;
        final Map<String, Integer> shares = new LinkedHashMap<>();
        final List<String> paid = new ArrayList<>();

        PayDesk(Mediator room) { this.room = room; }

        void lock() { room.notify("desk", "lock", "", 0); }

        int pay(String name) {
            room.notify("desk", "pay", name, 0);
            return shares.get(name);
        }

        void split(int total, List<String> names) { // equal shares; the first few members cover the remainder
            int base = total / names.size(), extra = total % names.size();
            for (int i = 0; i < names.size(); i++) shares.put(names.get(i), base + (i < extra ? 1 : 0));
        }
    }

    static final class Banner {
        String text = "";

        void show(String text) { this.text = text; }
    }

    /** The mediator: every rule about how the parts affect each other lives here. */
    static final class Room implements Mediator {
        final Cart cart = new Cart(this);
        final Roster roster = new Roster(this);
        final PayDesk desk = new PayDesk(this);
        final Banner banner = new Banner();
        final Map<String, Integer> heard = new TreeMap<>(); // events heard, by sender
        boolean locked;

        public void notify(String sender, String event, String name, int amount) {
            switch (event) {
                case "add" -> { requireOpen(); cart.put(name, amount); }
                case "join" -> { requireOpen(); roster.admit(name); }
                case "lock" -> {
                    if (roster.names.isEmpty()) throw new IllegalStateException("nobody has joined");
                    desk.split(cart.total(), roster.names);
                    locked = true;
                }
                case "pay" -> {
                    if (!locked) throw new IllegalStateException("lock the cart first");
                    desk.paid.add(name);
                }
                default -> throw new IllegalArgumentException("unknown event: " + event);
            }
            heard.merge(sender, 1, Integer::sum); // counted only when the rule did not refuse
            banner.show(summary());
        }

        private void requireOpen() {
            if (locked) throw new IllegalStateException("the cart is locked");
        }

        private String summary() {
            int total = cart.total(), count = roster.names.size();
            if (!locked) return "open: " + count + " members, " + cart.items.size() + " items, total " + total;
            if (desk.paid.size() == count) return "placed: total " + total + ", paid by " + count;
            return "locked: total " + total + ", " + desk.paid.size() + " of " + count + " paid";
        }
    }

    static void attempt(String label, Runnable action) {
        try {
            action.run();
        } catch (IllegalStateException e) {
            System.out.println(label + ": refused (" + e.getMessage() + ")");
        }
    }

    public static void main(String[] args) {
        Room room = new Room();
        for (String who : List.of("Asha", "Ben", "Chitra")) room.roster.join(who);
        room.cart.add("biryani", 250);
        room.cart.add("paneer", 180);
        room.cart.add("lassi", 60);
        System.out.println(room.banner.text);
        attempt("pay before lock", () -> room.desk.pay("Asha"));
        room.desk.lock();
        List<String> shares = new ArrayList<>();
        for (String n : room.roster.names) shares.add(n + " " + room.desk.shares.get(n));
        System.out.println("shares: " + String.join(", ", shares));
        attempt("add after lock", () -> room.cart.add("naan", 40));
        attempt("join after lock", () -> room.roster.join("Dev"));
        for (String who : List.of("Asha", "Ben")) System.out.println(who + " pays " + room.desk.pay(who));
        System.out.println(room.banner.text);
        System.out.println("Chitra pays " + room.desk.pay("Chitra"));
        System.out.println(room.banner.text);
        List<String> counts = new ArrayList<>();
        room.heard.forEach((k, v) -> counts.add(k + " " + v));
        System.out.println("events through the room: " + String.join(", ", counts));
    }
}

// group_room.cpp: the room is the only class that knows all the others
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>

// What a colleague knows about the room: how to tell it that something happened.
class Mediator {
public:
    virtual ~Mediator() = default;
    virtual void notify(const std::string& sender, const std::string& event, const std::string& name, int amount) = 0;
};

class Cart {
    Mediator& room_;
public:
    std::vector<std::pair<std::string, int>> items;
    explicit Cart(Mediator& room) : room_(room) {}
    void add(const std::string& name, int price) { room_.notify("cart", "add", name, price); }  // a user action: tell the room
    void put(const std::string& name, int price) { items.emplace_back(name, price); }           // what the room asks for
    int total() const {
        return std::accumulate(items.begin(), items.end(), 0, [](int sum, const auto& item) { return sum + item.second; });
    }
};

class Roster {
    Mediator& room_;
public:
    std::vector<std::string> names;
    explicit Roster(Mediator& room) : room_(room) {}
    void join(const std::string& name) { room_.notify("roster", "join", name, 0); }
    void admit(const std::string& name) { names.push_back(name); }
};

class PayDesk {
    Mediator& room_;
public:
    std::map<std::string, int> shares;
    std::vector<std::string> paid;
    explicit PayDesk(Mediator& room) : room_(room) {}
    void lock() { room_.notify("desk", "lock", "", 0); }
    int pay(const std::string& name) {
        room_.notify("desk", "pay", name, 0);
        return shares[name];
    }
    void split(int total, const std::vector<std::string>& names) {  // equal shares; the first few members cover the remainder
        int count = static_cast<int>(names.size()), base = total / count, extra = total % count;
        for (int i = 0; i < count; i++) shares[names[i]] = base + (i < extra ? 1 : 0);
    }
};

struct Banner {
    std::string text;
    void show(const std::string& t) { text = t; }
};

// The mediator: every rule about how the parts affect each other lives here.
class Room : public Mediator {
public:
    Cart cart{*this};
    Roster roster{*this};
    PayDesk desk{*this};
    Banner banner;
    std::map<std::string, int> heard;  // events heard, by sender
    bool locked = false;

    void notify(const std::string& sender, const std::string& event, const std::string& name, int amount) override {
        if (event == "add") {
            requireOpen();
            cart.put(name, amount);
        } else if (event == "join") {
            requireOpen();
            roster.admit(name);
        } else if (event == "lock") {
            if (roster.names.empty()) throw std::runtime_error("nobody has joined");
            desk.split(cart.total(), roster.names);
            locked = true;
        } else if (event == "pay") {
            if (!locked) throw std::runtime_error("lock the cart first");
            desk.paid.push_back(name);
        } else {
            throw std::invalid_argument("unknown event: " + event);
        }
        heard[sender] += 1;  // counted only when the rule did not refuse
        banner.show(summary());
    }

private:
    void requireOpen() const {
        if (locked) throw std::runtime_error("the cart is locked");
    }
    std::string summary() const {
        int total = cart.total(), count = static_cast<int>(roster.names.size()), paidCount = static_cast<int>(desk.paid.size());
        if (!locked) return "open: " + std::to_string(count) + " members, " + std::to_string(cart.items.size()) + " items, total " + std::to_string(total);
        if (paidCount == count) return "placed: total " + std::to_string(total) + ", paid by " + std::to_string(count);
        return "locked: total " + std::to_string(total) + ", " + std::to_string(paidCount) + " of " + std::to_string(count) + " paid";
    }
};

void attempt(const std::string& label, const std::function<void()>& action) {
    try {
        action();
    } catch (const std::runtime_error& e) {
        std::cout << label << ": refused (" << e.what() << ")\n";
    }
}

int main() {
    Room room;
    for (const char* who : {"Asha", "Ben", "Chitra"}) room.roster.join(who);
    room.cart.add("biryani", 250);
    room.cart.add("paneer", 180);
    room.cart.add("lassi", 60);
    std::cout << room.banner.text << "\n";
    attempt("pay before lock", [&] { room.desk.pay("Asha"); });
    room.desk.lock();
    std::cout << "shares: ";
    for (size_t i = 0; i < room.roster.names.size(); i++) {
        const std::string& n = room.roster.names[i];
        std::cout << (i ? ", " : "") << n << " " << room.desk.shares[n];
    }
    std::cout << "\n";
    attempt("add after lock", [&] { room.cart.add("naan", 40); });
    attempt("join after lock", [&] { room.roster.join("Dev"); });
    for (const char* who : {"Asha", "Ben"}) std::cout << who << " pays " << room.desk.pay(who) << "\n";
    std::cout << room.banner.text << "\n";
    std::cout << "Chitra pays " << room.desk.pay("Chitra") << "\n";
    std::cout << room.banner.text << "\n";
    std::cout << "events through the room: ";
    bool first = true;
    for (const auto& [sender, count] : room.heard) {
        std::cout << (first ? "" : ", ") << sender << " " << count;
        first = false;
    }
    std::cout << "\n";
}

// group_room.js: the room is the only class that knows all the others
class Cart {
  constructor(room) {
    Object.assign(this, { room, items: [] });
  }
  add(name, price) {
    this.room.notify("cart", "add", name, price); // a user action: tell the room, change nothing here
  }
  put(name, price) {
    this.items.push({ name, price }); // what the room asks the cart to do
  }
  total() {
    return this.items.reduce((sum, item) => sum + item.price, 0);
  }
}

class Roster {
  constructor(room) {
    Object.assign(this, { room, names: [] });
  }
  join(name) {
    this.room.notify("roster", "join", name);
  }
  admit(name) {
    this.names.push(name);
  }
}

class PayDesk {
  constructor(room) {
    Object.assign(this, { room, shares: {}, paid: [] });
  }
  lock() {
    this.room.notify("desk", "lock");
  }
  pay(name) {
    this.room.notify("desk", "pay", name);
    return this.shares[name];
  }
  split(total, names) {
    // equal shares; the first few members cover the remainder
    const base = Math.floor(total / names.length);
    const extra = total % names.length;
    names.forEach((n, i) => {
      this.shares[n] = base + (i < extra ? 1 : 0);
    });
  }
}

class Banner {
  text = "";
  show(text) {
    this.text = text;
  }
}

/** The mediator: every rule about how the parts affect each other lives here. */
class Room {
  constructor() {
    this.cart = new Cart(this);
    this.roster = new Roster(this);
    this.desk = new PayDesk(this);
    this.banner = new Banner();
    this.locked = false;
    this.heard = new Map(); // events heard, by sender
    this.rules = {
      add: (name, amount) => {
        this.requireOpen();
        this.cart.put(name, amount);
      },
      join: (name) => {
        this.requireOpen();
        this.roster.admit(name);
      },
      lock: () => {
        if (this.roster.names.length === 0) throw new Error("nobody has joined");
        this.desk.split(this.cart.total(), this.roster.names);
        this.locked = true;
      },
      pay: (name) => {
        if (!this.locked) throw new Error("lock the cart first");
        this.desk.paid.push(name);
      },
    };
  }
  notify(sender, event, name = "", amount = 0) {
    this.rules[event](name, amount);
    this.heard.set(sender, (this.heard.get(sender) ?? 0) + 1); // counted only when the rule did not refuse
    this.banner.show(this.summary());
  }
  requireOpen() {
    if (this.locked) throw new Error("the cart is locked");
  }
  summary() {
    const total = this.cart.total();
    const count = this.roster.names.length;
    if (!this.locked) return `open: ${count} members, ${this.cart.items.length} items, total ${total}`;
    if (this.desk.paid.length === count) return `placed: total ${total}, paid by ${count}`;
    return `locked: total ${total}, ${this.desk.paid.length} of ${count} paid`;
  }
}

function attempt(label, action) {
  try {
    action();
  } catch (e) {
    console.log(`${label}: refused (${e.message})`);
  }
}

const room = new Room();
for (const who of ["Asha", "Ben", "Chitra"]) room.roster.join(who);
for (const [item, price] of [["biryani", 250], ["paneer", 180], ["lassi", 60]]) room.cart.add(item, price);
console.log(room.banner.text);
attempt("pay before lock", () => room.desk.pay("Asha"));
room.desk.lock();
console.log("shares: " + room.roster.names.map((n) => `${n} ${room.desk.shares[n]}`).join(", "));
attempt("add after lock", () => room.cart.add("naan", 40));
attempt("join after lock", () => room.roster.join("Dev"));
for (const who of ["Asha", "Ben"]) console.log(`${who} pays ${room.desk.pay(who)}`);
console.log(room.banner.text);
console.log(`Chitra pays ${room.desk.pay("Chitra")}`);
console.log(room.banner.text);
console.log("events through the room: " + [...room.heard].sort(([a], [b]) => (a < b ? -1 : 1)).map(([k, v]) => `${k} ${v}`).join(", "));

# shallow_snapshot.py: copying the list is not copying what is in it
import copy


def render(lines):
    return "; ".join(f"{l['name']} x{l['qty']} [{', '.join(l['notes'])}]" for l in lines)


draft = [{"name": "biryani", "qty": 2, "notes": ["no onion"]}]
shallow = list(draft)  # a new list that holds the same line objects
deep = copy.deepcopy(draft)  # new lines with new notes
draft[0]["notes"].append("extra gravy")  # a later edit
print("draft now:        " + render(draft))
print("shallow snapshot: " + render(shallow))
print("deep snapshot:    " + render(deep))

// ShallowSnapshot.java: copying the list is not copying what is in it
import java.util.ArrayList;
import java.util.List;

class ShallowSnapshot {
    static final class Line {
        final String name;
        final int qty;
        final List<String> notes = new ArrayList<>();

        Line(String name, int qty) { this.name = name; this.qty = qty; }

        Line copy() {
            Line c = new Line(name, qty);
            c.notes.addAll(notes);
            return c;
        }
    }

    static String render(List<Line> lines) {
        List<String> parts = new ArrayList<>();
        for (Line l : lines) parts.add(l.name + " x" + l.qty + " [" + String.join(", ", l.notes) + "]");
        return String.join("; ", parts);
    }

    public static void main(String[] args) {
        List<Line> draft = new ArrayList<>();
        Line biryani = new Line("biryani", 2);
        biryani.notes.add("no onion");
        draft.add(biryani);

        List<Line> shallow = new ArrayList<>(draft); // a new list that holds the same Line objects
        List<Line> deep = new ArrayList<>();         // new Lines with new notes
        for (Line l : draft) deep.add(l.copy());
        biryani.notes.add("extra gravy"); // a later edit
        System.out.println("draft now:        " + render(draft));
        System.out.println("shallow snapshot: " + render(shallow));
        System.out.println("deep snapshot:    " + render(deep));
    }
}

// shallow_snapshot.cpp: copying the list is not copying what is in it
#include <iostream>
#include <memory>
#include <string>
#include <vector>

struct Line {
    std::string name;
    int qty;
    std::vector<std::string> notes;
};

// The lines are held by pointer, so a copy of the vector copies the pointers, not the lines.
using Lines = std::vector<std::shared_ptr<Line>>;

std::string render(const Lines& lines) {
    std::string out;
    for (const auto& l : lines) {
        if (!out.empty()) out += "; ";
        out += l->name + " x" + std::to_string(l->qty) + " [";
        for (size_t i = 0; i < l->notes.size(); i++) out += (i ? ", " : "") + l->notes[i];
        out += "]";
    }
    return out;
}

int main() {
    Lines draft{std::make_shared<Line>(Line{"biryani", 2, {"no onion"}})};
    Lines shallow = draft;  // a new vector that holds the same Line objects
    Lines deep;             // new Lines with new notes
    for (const auto& l : draft) deep.push_back(std::make_shared<Line>(*l));
    draft[0]->notes.push_back("extra gravy");  // a later edit
    std::cout << "draft now:        " << render(draft) << "\n";
    std::cout << "shallow snapshot: " << render(shallow) << "\n";
    std::cout << "deep snapshot:    " << render(deep) << "\n";
}

// shallow_snapshot.js: copying the list is not copying what is in it
const render = (lines) => lines.map((l) => `${l.name} x${l.qty} [${l.notes.join(", ")}]`).join("; ");

const draft = [{ name: "biryani", qty: 2, notes: ["no onion"] }];
const shallow = [...draft]; // a new array that holds the same line objects
const deep = structuredClone(draft); // new lines with new notes
draft[0].notes.push("extra gravy"); // a later edit
console.log("draft now:        " + render(draft));
console.log("shallow snapshot: " + render(shallow));
console.log("deep snapshot:    " + render(deep));

# autosave.py: the draft seals a snapshot; the autosave keeps snapshots without opening one
import copy


class Memento:
    """A sealed snapshot. Only Draft reads _state; everyone else just holds it."""

    def __init__(self, state):
        self._state = state


class Draft:
    """The originator: it alone knows what its state looks like inside."""

    def __init__(self):
        self._lines = []

    def add(self, name, qty):
        self._lines.append({"name": name, "qty": qty, "notes": []})

    def note(self, name, text):
        self._find(name)["notes"].append(text)

    def remove(self, name):
        self._lines.remove(self._find(name))

    def render(self):
        return "; ".join(f"{l['name']} x{l['qty']}" + (f" [{', '.join(l['notes'])}]" if l["notes"] else "") for l in self._lines) or "(empty)"

    def save(self):
        return Memento(copy.deepcopy(self._lines))

    def restore(self, memento):
        self._lines = copy.deepcopy(memento._state)  # copy again, so the memento stays good for next time

    def _find(self, name):
        return next(l for l in self._lines if l["name"] == name)


class Autosave:
    """The caretaker: it decides when to save and how many to keep, and never looks inside."""

    def __init__(self, draft, every=3, keep=2):
        self.draft, self.every, self.keep = draft, every, keep
        self.edits, self.saves, self.kept = 0, 0, []

    def edited(self):
        self.edits += 1
        if self.edits % self.every == 0:
            self.kept.append(self.draft.save())
            self.saves += 1
            del self.kept[:-self.keep]  # drop the oldest beyond the limit

    def restore(self, back=1):  # 1 is the newest autosave, 2 the one before it
        self.draft.restore(self.kept[-back])


draft = Draft()
auto = Autosave(draft)


def edit(action):
    action()
    auto.edited()


edit(lambda: draft.add("biryani", 2))
edit(lambda: draft.add("lassi", 1))
edit(lambda: draft.note("biryani", "no onion"))
print(f"after {auto.edits} edits: {draft.render()} | saved {auto.saves}, kept {len(auto.kept)}")
edit(lambda: draft.remove("lassi"))
edit(lambda: draft.add("paneer", 1))
edit(lambda: draft.note("paneer", "extra spicy"))
print(f"after {auto.edits} edits: {draft.render()} | saved {auto.saves}, kept {len(auto.kept)}")
edit(lambda: draft.add("naan", 2))
edit(lambda: draft.note("naan", "butter"))
edit(lambda: draft.remove("biryani"))
print(f"after {auto.edits} edits: {draft.render()} | saved {auto.saves}, kept {len(auto.kept)}")
auto.restore(2)
print("restored the older save:", draft.render())
draft.add("tea", 1)
auto.restore(2)
print("restored it again:      ", draft.render())

// Autosave.java: the draft seals a snapshot; the autosave keeps snapshots without opening one
import java.util.ArrayList;
import java.util.List;

class Autosave {
    /** What anyone but Draft sees of a snapshot: nothing to read. */
    interface Memento {}

    static final class Line {
        final String name;
        final int qty;
        final List<String> notes = new ArrayList<>();

        Line(String name, int qty) { this.name = name; this.qty = qty; }

        Line copy() {
            Line c = new Line(name, qty);
            c.notes.addAll(notes);
            return c;
        }
    }

    /** The originator: it alone knows what its state looks like inside. */
    static final class Draft {
        private record Saved(List<Line> lines) implements Memento {}

        private List<Line> lines = new ArrayList<>();

        void add(String name, int qty) { lines.add(new Line(name, qty)); }
        void note(String name, String text) { find(name).notes.add(text); }
        void remove(String name) { lines.remove(find(name)); }

        String render() {
            List<String> parts = new ArrayList<>();
            for (Line l : lines) parts.add(l.name + " x" + l.qty + (l.notes.isEmpty() ? "" : " [" + String.join(", ", l.notes) + "]"));
            return parts.isEmpty() ? "(empty)" : String.join("; ", parts);
        }

        Memento save() { return new Saved(copyOf(lines)); }

        void restore(Memento m) { lines = copyOf(((Saved) m).lines()); } // copy again, so the memento stays good

        private Line find(String name) {
            return lines.stream().filter(l -> l.name.equals(name)).findFirst().orElseThrow();
        }

        private static List<Line> copyOf(List<Line> source) {
            List<Line> out = new ArrayList<>();
            for (Line l : source) out.add(l.copy());
            return out;
        }
    }

    /** The caretaker: it decides when to save and how many to keep, and never looks inside. */
    static final class Saver {
        final Draft draft;
        final int every, keep;
        final List<Memento> kept = new ArrayList<>();
        int edits, saves;

        Saver(Draft draft, int every, int keep) { this.draft = draft; this.every = every; this.keep = keep; }

        void edited() {
            edits++;
            if (edits % every == 0) {
                kept.add(draft.save());
                saves++;
                if (kept.size() > keep) kept.remove(0); // drop the oldest beyond the limit
            }
        }

        void restore(int back) { draft.restore(kept.get(kept.size() - back)); } // 1 is the newest, 2 the one before
    }

    static void edit(Saver saver, Runnable action) {
        action.run();
        saver.edited();
    }

    static void report(Saver s) {
        System.out.println("after " + s.edits + " edits: " + s.draft.render() + " | saved " + s.saves + ", kept " + s.kept.size());
    }

    public static void main(String[] args) {
        Draft draft = new Draft();
        Saver auto = new Saver(draft, 3, 2);
        edit(auto, () -> draft.add("biryani", 2));
        edit(auto, () -> draft.add("lassi", 1));
        edit(auto, () -> draft.note("biryani", "no onion"));
        report(auto);
        edit(auto, () -> draft.remove("lassi"));
        edit(auto, () -> draft.add("paneer", 1));
        edit(auto, () -> draft.note("paneer", "extra spicy"));
        report(auto);
        edit(auto, () -> draft.add("naan", 2));
        edit(auto, () -> draft.note("naan", "butter"));
        edit(auto, () -> draft.remove("biryani"));
        report(auto);
        auto.restore(2);
        System.out.println("restored the older save: " + draft.render());
        draft.add("tea", 1);
        auto.restore(2);
        System.out.println("restored it again:       " + draft.render());
    }
}

// autosave.cpp: the draft seals a snapshot; the autosave keeps snapshots without opening one
#include <algorithm>
#include <functional>
#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>

struct Line {
    std::string name;
    int qty;
    std::vector<std::string> notes;
};

// The originator: it alone knows what its state looks like inside.
class Draft {
    std::vector<Line> lines_;  // held by value, so copying the vector copies the lines too

    Line& find(const std::string& name) {
        auto it = std::find_if(lines_.begin(), lines_.end(), [&](const Line& l) { return l.name == name; });
        if (it == lines_.end()) throw std::invalid_argument("no line " + name);
        return *it;
    }

public:
    // A sealed snapshot: only Draft can build one or open one.
    class Memento {
        friend class Draft;
        std::vector<Line> state_;
        explicit Memento(std::vector<Line> state) : state_(std::move(state)) {}
    };

    void add(const std::string& name, int qty) { lines_.push_back({name, qty, {}}); }
    void note(const std::string& name, const std::string& text) { find(name).notes.push_back(text); }
    void remove(const std::string& name) { lines_.erase(lines_.begin() + (&find(name) - lines_.data())); }

    std::string render() const {
        std::string out;
        for (const Line& l : lines_) {
            if (!out.empty()) out += "; ";
            out += l.name + " x" + std::to_string(l.qty);
            for (size_t i = 0; i < l.notes.size(); i++) out += (i ? ", " : " [") + l.notes[i] + (i + 1 == l.notes.size() ? "]" : "");
        }
        return out.empty() ? "(empty)" : out;
    }

    Memento save() const { return Memento(lines_); }
    void restore(const Memento& m) { lines_ = m.state_; }  // a copy, so the memento stays good for next time
};

// The caretaker: it decides when to save and how many to keep, and never looks inside.
class Autosave {
public:
    Draft& draft;
    int every, keep, edits = 0, saves = 0;
    std::vector<Draft::Memento> kept;

    Autosave(Draft& d, int every_, int keep_) : draft(d), every(every_), keep(keep_) {}

    void edited() {
        edits++;
        if (edits % every == 0) {
            kept.push_back(draft.save());
            saves++;
            if (static_cast<int>(kept.size()) > keep) kept.erase(kept.begin());  // drop the oldest beyond the limit
        }
    }
    void restore(int back) { draft.restore(kept[kept.size() - back]); }  // 1 is the newest, 2 the one before
};

void edit(Autosave& auto_, const std::function<void()>& action) {
    action();
    auto_.edited();
}

void report(const Autosave& a) {
    std::cout << "after " << a.edits << " edits: " << a.draft.render() << " | saved " << a.saves << ", kept " << a.kept.size() << "\n";
}

int main() {
    Draft draft;
    Autosave autosave(draft, 3, 2);
    edit(autosave, [&] { draft.add("biryani", 2); });
    edit(autosave, [&] { draft.add("lassi", 1); });
    edit(autosave, [&] { draft.note("biryani", "no onion"); });
    report(autosave);
    edit(autosave, [&] { draft.remove("lassi"); });
    edit(autosave, [&] { draft.add("paneer", 1); });
    edit(autosave, [&] { draft.note("paneer", "extra spicy"); });
    report(autosave);
    edit(autosave, [&] { draft.add("naan", 2); });
    edit(autosave, [&] { draft.note("naan", "butter"); });
    edit(autosave, [&] { draft.remove("biryani"); });
    report(autosave);
    autosave.restore(2);
    std::cout << "restored the older save: " << draft.render() << "\n";
    draft.add("tea", 1);
    autosave.restore(2);
    std::cout << "restored it again:       " << draft.render() << "\n";
}

// autosave.js: the draft seals a snapshot; the autosave keeps snapshots without opening one
const sealed = new WeakMap(); // memento -> state; only this module can open one

/** The originator: it alone knows what its state looks like inside. */
class Draft {
  #lines = [];

  add(name, qty) {
    this.#lines.push({ name, qty, notes: [] });
  }
  note(name, text) {
    this.#find(name).notes.push(text);
  }
  remove(name) {
    this.#lines.splice(this.#lines.indexOf(this.#find(name)), 1);
  }
  render() {
    const parts = this.#lines.map((l) => `${l.name} x${l.qty}` + (l.notes.length ? ` [${l.notes.join(", ")}]` : ""));
    return parts.join("; ") || "(empty)";
  }
  save() {
    const memento = Object.freeze({}); // an empty, frozen box: nothing to read from outside
    sealed.set(memento, structuredClone(this.#lines));
    return memento;
  }
  restore(memento) {
    this.#lines = structuredClone(sealed.get(memento)); // copy again, so the memento stays good for next time
  }
  #find(name) {
    return this.#lines.find((l) => l.name === name);
  }
}

/** The caretaker: it decides when to save and how many to keep, and never looks inside. */
class Autosave {
  constructor(draft, every = 3, keep = 2) {
    Object.assign(this, { draft, every, keep, edits: 0, saves: 0, kept: [] });
  }
  edited() {
    this.edits++;
    if (this.edits % this.every === 0) {
      this.kept.push(this.draft.save());
      this.saves++;
      if (this.kept.length > this.keep) this.kept.shift(); // drop the oldest beyond the limit
    }
  }
  restore(back = 1) {
    // 1 is the newest autosave, 2 the one before it
    this.draft.restore(this.kept[this.kept.length - back]);
  }
}

const draft = new Draft();
const auto = new Autosave(draft);
const edit = (action) => {
  action();
  auto.edited();
};
const report = () => console.log(`after ${auto.edits} edits: ${draft.render()} | saved ${auto.saves}, kept ${auto.kept.length}`);

edit(() => draft.add("biryani", 2));
edit(() => draft.add("lassi", 1));
edit(() => draft.note("biryani", "no onion"));
report();
edit(() => draft.remove("lassi"));
edit(() => draft.add("paneer", 1));
edit(() => draft.note("paneer", "extra spicy"));
report();
edit(() => draft.add("naan", 2));
edit(() => draft.note("naan", "butter"));
edit(() => draft.remove("biryani"));
report();
auto.restore(2);
console.log("restored the older save: " + draft.render());
draft.add("tea", 1);
auto.restore(2);
console.log("restored it again:       " + draft.render());