Bridge and Flyweight.

# first_version.py: one class for every kind and channel pair: 3 kinds x 3 channels = 9 classes
class Notification:  # the base: it knows who to send to and one detail (an order id or a code), and nothing else
    def __init__(self, to: str, detail: int = 0) -> None:
        self.to, self.detail = to, detail


class OrderShippedEmail(Notification):
    def send(self) -> str:
        return f"[email to {self.to}] Order shipped: Order {self.detail} is on its way"


class OrderShippedSms(Notification):  # the same words again, cut at 40 characters
    def send(self) -> str:
        return f"[sms to {self.to}] " + f"Order shipped: Order {self.detail} is on its way"[:40]


class OrderShippedPush(Notification):
    def send(self) -> str:
        return f"[push to {self.to}] Order shipped / Order {self.detail} is on its way"


class OtpEmail(Notification):
    def send(self) -> str:
        return f"[email to {self.to}] Your code: {self.detail} is valid for 5 minutes"


class OtpSms(Notification):
    def send(self) -> str:
        return f"[sms to {self.to}] " + f"Your code: {self.detail} is valid for 5 minutes"[:40]


class OtpPush(Notification):
    def send(self) -> str:
        return f"[push to {self.to}] Your code / {self.detail} is valid for 5 minutes"


class PromoEmail(Notification):
    def send(self) -> str:
        return f"[email to {self.to}] Weekend offer: 20 percent off wraps till Sunday"


class PromoSms(Notification):
    def send(self) -> str:
        return f"[sms to {self.to}] " + "Weekend offer: 20 percent off wraps till Sunday"[:40]


class PromoPush(Notification):
    def send(self) -> str:
        return f"[push to {self.to}] Weekend offer / 20 percent off wraps till Sunday"


for message in (OrderShippedEmail("asha", 77), OrderShippedSms("asha", 77), OtpSms("asha", 482913), PromoSms("asha"), PromoPush("asha")):
    print(message.send())

// FirstVersion.java: one class for every kind and channel pair: 3 kinds x 3 channels = 9 classes
class FirstVersion {
    static abstract class Notification { // the base: it knows who to send to and one detail (an order id or a code), and nothing else
        final String to;
        final int detail;

        Notification(String to, int detail) {
            this.to = to;
            this.detail = detail;
        }

        abstract String send();
    }

    static String cut(String text) { return text.length() > 40 ? text.substring(0, 40) : text; }

    static final class OrderShippedEmail extends Notification {
        OrderShippedEmail(String to, int detail) { super(to, detail); }

        String send() { return "[email to " + to + "] Order shipped: Order " + detail + " is on its way"; }
    }

    static final class OrderShippedSms extends Notification { // the same words again, cut at 40 characters
        OrderShippedSms(String to, int detail) { super(to, detail); }

        String send() { return "[sms to " + to + "] " + cut("Order shipped: Order " + detail + " is on its way"); }
    }

    static final class OrderShippedPush extends Notification {
        OrderShippedPush(String to, int detail) { super(to, detail); }

        String send() { return "[push to " + to + "] Order shipped / Order " + detail + " is on its way"; }
    }

    static final class OtpEmail extends Notification {
        OtpEmail(String to, int detail) { super(to, detail); }

        String send() { return "[email to " + to + "] Your code: " + detail + " is valid for 5 minutes"; }
    }

    static final class OtpSms extends Notification {
        OtpSms(String to, int detail) { super(to, detail); }

        String send() { return "[sms to " + to + "] " + cut("Your code: " + detail + " is valid for 5 minutes"); }
    }

    static final class OtpPush extends Notification {
        OtpPush(String to, int detail) { super(to, detail); }

        String send() { return "[push to " + to + "] Your code / " + detail + " is valid for 5 minutes"; }
    }

    static final class PromoEmail extends Notification {
        PromoEmail(String to, int detail) { super(to, detail); }

        String send() { return "[email to " + to + "] Weekend offer: 20 percent off wraps till Sunday"; }
    }

    static final class PromoSms extends Notification {
        PromoSms(String to, int detail) { super(to, detail); }

        String send() { return "[sms to " + to + "] " + cut("Weekend offer: 20 percent off wraps till Sunday"); }
    }

    static final class PromoPush extends Notification {
        PromoPush(String to, int detail) { super(to, detail); }

        String send() { return "[push to " + to + "] Weekend offer / 20 percent off wraps till Sunday"; }
    }

    public static void main(String[] args) {
        Notification[] messages = {new OrderShippedEmail("asha", 77), new OrderShippedSms("asha", 77), new OtpSms("asha", 482913), new PromoSms("asha", 0), new PromoPush("asha", 0)};
        for (Notification message : messages) System.out.println(message.send());
    }
}

// first_version.cpp: one class for every kind and channel pair: 3 kinds x 3 channels = 9 classes
#include <iostream>
#include <memory>
#include <string>
#include <utility>
#include <vector>

class Notification {  // the base: it knows who to send to and one detail (an order id or a code), and nothing else
public:
    explicit Notification(std::string to, int detail = 0) : to_(std::move(to)), detail_(detail) {}
    virtual ~Notification() = default;
    virtual std::string send() const = 0;

protected:
    std::string to_;
    int detail_;
};

std::string cut(const std::string& text) { return text.substr(0, 40); }

class OrderShippedEmail : public Notification {
public:
    using Notification::Notification;
    std::string send() const override { return "[email to " + to_ + "] Order shipped: Order " + std::to_string(detail_) + " is on its way"; }
};

class OrderShippedSms : public Notification {  // the same words again, cut at 40 characters
public:
    using Notification::Notification;
    std::string send() const override { return "[sms to " + to_ + "] " + cut("Order shipped: Order " + std::to_string(detail_) + " is on its way"); }
};

class OrderShippedPush : public Notification {
public:
    using Notification::Notification;
    std::string send() const override { return "[push to " + to_ + "] Order shipped / Order " + std::to_string(detail_) + " is on its way"; }
};

class OtpEmail : public Notification {
public:
    using Notification::Notification;
    std::string send() const override { return "[email to " + to_ + "] Your code: " + std::to_string(detail_) + " is valid for 5 minutes"; }
};

class OtpSms : public Notification {
public:
    using Notification::Notification;
    std::string send() const override { return "[sms to " + to_ + "] " + cut("Your code: " + std::to_string(detail_) + " is valid for 5 minutes"); }
};

class OtpPush : public Notification {
public:
    using Notification::Notification;
    std::string send() const override { return "[push to " + to_ + "] Your code / " + std::to_string(detail_) + " is valid for 5 minutes"; }
};

class PromoEmail : public Notification {
public:
    using Notification::Notification;
    std::string send() const override { return "[email to " + to_ + "] Weekend offer: 20 percent off wraps till Sunday"; }
};

class PromoSms : public Notification {
public:
    using Notification::Notification;
    std::string send() const override { return "[sms to " + to_ + "] " + cut("Weekend offer: 20 percent off wraps till Sunday"); }
};

class PromoPush : public Notification {
public:
    using Notification::Notification;
    std::string send() const override { return "[push to " + to_ + "] Weekend offer / 20 percent off wraps till Sunday"; }
};

int main() {
    std::vector<std::unique_ptr<Notification>> messages;
    messages.push_back(std::make_unique<OrderShippedEmail>("asha", 77));
    messages.push_back(std::make_unique<OrderShippedSms>("asha", 77));
    messages.push_back(std::make_unique<OtpSms>("asha", 482913));
    messages.push_back(std::make_unique<PromoSms>("asha"));
    messages.push_back(std::make_unique<PromoPush>("asha"));
    for (const auto& message : messages) std::cout << message->send() << "\n";
}

// firstVersion.js: one class for every kind and channel pair: 3 kinds x 3 channels = 9 classes
class Notification { // the base: it knows who to send to and one detail (an order id or a code), and nothing else
  constructor(to, detail = 0) {
    this.to = to;
    this.detail = detail;
  }
}

const cut = (text) => text.slice(0, 40);

class OrderShippedEmail extends Notification {
  send() { return `[email to ${this.to}] Order shipped: Order ${this.detail} is on its way`; }
}

class OrderShippedSms extends Notification { // the same words again, cut at 40 characters
  send() { return `[sms to ${this.to}] ` + cut(`Order shipped: Order ${this.detail} is on its way`); }
}

class OrderShippedPush extends Notification {
  send() { return `[push to ${this.to}] Order shipped / Order ${this.detail} is on its way`; }
}

class OtpEmail extends Notification {
  send() { return `[email to ${this.to}] Your code: ${this.detail} is valid for 5 minutes`; }
}

class OtpSms extends Notification {
  send() { return `[sms to ${this.to}] ` + cut(`Your code: ${this.detail} is valid for 5 minutes`); }
}

class OtpPush extends Notification {
  send() { return `[push to ${this.to}] Your code / ${this.detail} is valid for 5 minutes`; }
}

class PromoEmail extends Notification {
  send() { return `[email to ${this.to}] Weekend offer: 20 percent off wraps till Sunday`; }
}

class PromoSms extends Notification {
  send() { return `[sms to ${this.to}] ` + cut("Weekend offer: 20 percent off wraps till Sunday"); }
}

class PromoPush extends Notification {
  send() { return `[push to ${this.to}] Weekend offer / 20 percent off wraps till Sunday`; }
}

for (const message of [new OrderShippedEmail("asha", 77), new OrderShippedSms("asha", 77), new OtpSms("asha", 482913), new PromoSms("asha"), new PromoPush("asha")]) {
  console.log(message.send());
}

# bridge.py: what is said (the kind) and how it goes out (the channel) are two hierarchies joined by one reference
from abc import ABC, abstractmethod


class Channel(ABC):  # the implementation side: how a message physically goes out
    @abstractmethod
    def deliver(self, to: str, title: str, body: str) -> str: ...


class Email(Channel):
    def deliver(self, to: str, title: str, body: str) -> str:
        return f"[email to {to}] {title}: {body}"


class Sms(Channel):
    def deliver(self, to: str, title: str, body: str) -> str:
        return f"[sms to {to}] " + f"{title}: {body}"[:40]  # a text message has a limit


class Push(Channel):
    def deliver(self, to: str, title: str, body: str) -> str:
        return f"[push to {to}] {title} / {body}"


class Chat(Channel):  # added later: one new class, and no kind is edited
    def deliver(self, to: str, title: str, body: str) -> str:
        return f"[chat to {to}] {title} | {body}"


class Notification(ABC):  # the abstraction: what is being said, holding a channel
    def __init__(self, to: str, channel: Channel) -> None:
        self.to, self.channel = to, channel

    @abstractmethod
    def title(self) -> str: ...

    @abstractmethod
    def body(self) -> str: ...

    def send(self) -> str:
        return self.channel.deliver(self.to, self.title(), self.body())


class OrderShipped(Notification):
    def __init__(self, to: str, channel: Channel, order_id: int) -> None:
        super().__init__(to, channel)
        self.order_id = order_id

    def title(self) -> str:
        return "Order shipped"

    def body(self) -> str:
        return f"Order {self.order_id} is on its way"


class Otp(Notification):
    def __init__(self, to: str, channel: Channel, code: int) -> None:
        super().__init__(to, channel)
        self.code = code

    def title(self) -> str:
        return "Your code"

    def body(self) -> str:
        return f"{self.code} is valid for 5 minutes"


class Promo(Notification):
    def title(self) -> str:
        return "Weekend offer"

    def body(self) -> str:
        return "20 percent off wraps till Sunday"


def every_kind(channel: Channel) -> list:
    return [OrderShipped("asha", channel, 77), Otp("asha", channel, 482913), Promo("asha", channel)]


channels = [Email(), Sms(), Push(), Chat()]
sent = [n.send() for channel in channels for n in every_kind(channel)]
for i in (0, 3, 6, 5, 11):  # order shipped by email, sms and push; the promo by sms and chat
    print(sent[i])
kinds = len(every_kind(channels[0]))
print(f"{len(sent)} messages: {kinds} kinds x {len(channels)} channels, {kinds + len(channels)} classes written")

// Bridge.java: what is said (the kind) and how it goes out (the channel) are two hierarchies joined by one reference
import java.util.ArrayList;
import java.util.List;

class Bridge {
    interface Channel { // the implementation side: how a message physically goes out
        String deliver(String to, String title, String body);
    }

    static final class Email implements Channel {
        public String deliver(String to, String title, String body) { return "[email to " + to + "] " + title + ": " + body; }
    }

    static final class Sms implements Channel {
        public String deliver(String to, String title, String body) {
            String text = title + ": " + body;
            return "[sms to " + to + "] " + (text.length() > 40 ? text.substring(0, 40) : text); // a text message has a limit
        }
    }

    static final class Push implements Channel {
        public String deliver(String to, String title, String body) { return "[push to " + to + "] " + title + " / " + body; }
    }

    static final class Chat implements Channel { // added later: one new class, and no kind is edited
        public String deliver(String to, String title, String body) { return "[chat to " + to + "] " + title + " | " + body; }
    }

    static abstract class Notification { // the abstraction: what is being said, holding a channel
        private final String to;
        private final Channel channel;

        Notification(String to, Channel channel) {
            this.to = to;
            this.channel = channel;
        }

        abstract String title();

        abstract String body();

        String send() { return channel.deliver(to, title(), body()); }
    }

    static final class OrderShipped extends Notification {
        private final int orderId;

        OrderShipped(String to, Channel channel, int orderId) {
            super(to, channel);
            this.orderId = orderId;
        }

        String title() { return "Order shipped"; }

        String body() { return "Order " + orderId + " is on its way"; }
    }

    static final class Otp extends Notification {
        private final int code;

        Otp(String to, Channel channel, int code) {
            super(to, channel);
            this.code = code;
        }

        String title() { return "Your code"; }

        String body() { return code + " is valid for 5 minutes"; }
    }

    static final class Promo extends Notification {
        Promo(String to, Channel channel) { super(to, channel); }

        String title() { return "Weekend offer"; }

        String body() { return "20 percent off wraps till Sunday"; }
    }

    static List<Notification> everyKind(Channel channel) {
        return List.of(new OrderShipped("asha", channel, 77), new Otp("asha", channel, 482913), new Promo("asha", channel));
    }

    public static void main(String[] args) {
        List<Channel> channels = List.of(new Email(), new Sms(), new Push(), new Chat());
        List<String> sent = new ArrayList<>();
        for (Channel channel : channels) for (Notification n : everyKind(channel)) sent.add(n.send());
        for (int i : new int[] {0, 3, 6, 5, 11}) System.out.println(sent.get(i)); // order shipped by email, sms and push; the promo by sms and chat
        int kinds = everyKind(channels.get(0)).size();
        System.out.println(sent.size() + " messages: " + kinds + " kinds x " + channels.size() + " channels, " + (kinds + channels.size()) + " classes written");
    }
}

// bridge.cpp: what is said (the kind) and how it goes out (the channel) are two hierarchies joined by one reference
#include <iostream>
#include <memory>
#include <string>
#include <utility>
#include <vector>

class Channel {  // the implementation side: how a message physically goes out
public:
    virtual ~Channel() = default;
    virtual std::string deliver(const std::string& to, const std::string& title, const std::string& body) const = 0;
};

class Email : public Channel {
public:
    std::string deliver(const std::string& to, const std::string& title, const std::string& body) const override { return "[email to " + to + "] " + title + ": " + body; }
};

class Sms : public Channel {
public:
    std::string deliver(const std::string& to, const std::string& title, const std::string& body) const override {
        return "[sms to " + to + "] " + (title + ": " + body).substr(0, 40);  // a text message has a limit
    }
};

class Push : public Channel {
public:
    std::string deliver(const std::string& to, const std::string& title, const std::string& body) const override { return "[push to " + to + "] " + title + " / " + body; }
};

class Chat : public Channel {  // added later: one new class, and no kind is edited
public:
    std::string deliver(const std::string& to, const std::string& title, const std::string& body) const override { return "[chat to " + to + "] " + title + " | " + body; }
};

class Notification {  // the abstraction: what is being said, holding a channel
public:
    Notification(std::string to, const Channel& channel) : to_(std::move(to)), channel_(channel) {}
    virtual ~Notification() = default;
    virtual std::string title() const = 0;
    virtual std::string body() const = 0;
    std::string send() const { return channel_.deliver(to_, title(), body()); }

private:
    std::string to_;
    const Channel& channel_;
};

class OrderShipped : public Notification {
public:
    OrderShipped(std::string to, const Channel& channel, int order_id) : Notification(std::move(to), channel), order_id_(order_id) {}
    std::string title() const override { return "Order shipped"; }
    std::string body() const override { return "Order " + std::to_string(order_id_) + " is on its way"; }

private:
    int order_id_;
};

class Otp : public Notification {
public:
    Otp(std::string to, const Channel& channel, int code) : Notification(std::move(to), channel), code_(code) {}
    std::string title() const override { return "Your code"; }
    std::string body() const override { return std::to_string(code_) + " is valid for 5 minutes"; }

private:
    int code_;
};

class Promo : public Notification {
public:
    Promo(std::string to, const Channel& channel) : Notification(std::move(to), channel) {}
    std::string title() const override { return "Weekend offer"; }
    std::string body() const override { return "20 percent off wraps till Sunday"; }
};

std::vector<std::unique_ptr<Notification>> every_kind(const Channel& channel) {
    std::vector<std::unique_ptr<Notification>> kinds;
    kinds.push_back(std::make_unique<OrderShipped>("asha", channel, 77));
    kinds.push_back(std::make_unique<Otp>("asha", channel, 482913));
    kinds.push_back(std::make_unique<Promo>("asha", channel));
    return kinds;
}

int main() {
    Email email;
    Sms sms;
    Push push;
    Chat chat;
    const std::vector<const Channel*> channels = {&email, &sms, &push, &chat};
    std::vector<std::string> sent;
    for (const Channel* channel : channels)
        for (const auto& n : every_kind(*channel)) sent.push_back(n->send());
    for (int i : {0, 3, 6, 5, 11}) std::cout << sent[i] << "\n";  // order shipped by email, sms and push; the promo by sms and chat
    size_t kinds = every_kind(email).size();
    std::cout << sent.size() << " messages: " << kinds << " kinds x " << channels.size() << " channels, " << kinds + channels.size() << " classes written\n";
}

// bridge.js: what is said (the kind) and how it goes out (the channel) are two hierarchies joined by one reference
class Email { // the implementation side: how a message physically goes out
  deliver(to, title, body) { return `[email to ${to}] ${title}: ${body}`; }
}

class Sms {
  deliver(to, title, body) { return `[sms to ${to}] ` + `${title}: ${body}`.slice(0, 40); } // a text message has a limit
}

class Push {
  deliver(to, title, body) { return `[push to ${to}] ${title} / ${body}`; }
}

class Chat { // added later: one new class, and no kind is edited
  deliver(to, title, body) { return `[chat to ${to}] ${title} | ${body}`; }
}

class Notification { // the abstraction: what is being said, holding a channel
  constructor(to, channel) {
    this.to = to;
    this.channel = channel;
  }

  send() { return this.channel.deliver(this.to, this.title(), this.body()); }
}

class OrderShipped extends Notification {
  constructor(to, channel, orderId) {
    super(to, channel);
    this.orderId = orderId;
  }

  title() { return "Order shipped"; }

  body() { return `Order ${this.orderId} is on its way`; }
}

class Otp extends Notification {
  constructor(to, channel, code) {
    super(to, channel);
    this.code = code;
  }

  title() { return "Your code"; }

  body() { return `${this.code} is valid for 5 minutes`; }
}

class Promo extends Notification {
  title() { return "Weekend offer"; }

  body() { return "20 percent off wraps till Sunday"; }
}

const everyKind = (channel) => [new OrderShipped("asha", channel, 77), new Otp("asha", channel, 482913), new Promo("asha", channel)];

const channels = [new Email(), new Sms(), new Push(), new Chat()];
const sent = channels.flatMap((channel) => everyKind(channel).map((n) => n.send()));
for (const i of [0, 3, 6, 5, 11]) console.log(sent[i]); // order shipped by email, sms and push; the promo by sms and chat
const kinds = everyKind(channels[0]).length;
console.log(`${sent.length} messages: ${kinds} kinds x ${channels.length} channels, ${kinds + channels.length} classes written`);

# seats_first_version.py: every seat builds its own copy of what its kind means
TABLE = {"regular": (200, 80), "premium": (350, 95), "recliner": (600, 120)}  # price in rupees, legroom in cm


def kind_name(row: int) -> str:  # rows 0-4 are recliners, rows 5-14 premium, the rest regular
    return "recliner" if row < 5 else "premium" if row < 15 else "regular"


class Details:  # what a kind of seat means: identical for every seat of that kind
    created = 0

    def __init__(self, name: str, price: int, legroom: int) -> None:
        self.name, self.price, self.legroom = name, price, legroom
        Details.created += 1


class Seat:
    def __init__(self, row: int, number: int) -> None:
        price, legroom = TABLE[kind_name(row)]
        self.row, self.number = row, number
        self.details = Details(kind_name(row), price, legroom)  # a new copy for every seat


seats = [Seat(row, number) for row in range(40) for number in range(50)]
print(f"seats: {len(seats)}")
print(f"details objects: {Details.created}")
print(f"two regular seats share their details: {'yes' if seats[-1].details is seats[-2].details else 'no'}")
first = seats[0]
print(f"row {first.row} seat {first.number}: {first.details.name}, {first.details.price} rupees, {first.details.legroom} cm")

// SeatsFirstVersion.java: every seat builds its own copy of what its kind means
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

class SeatsFirstVersion {
    static final Map<String, int[]> TABLE = Map.of("regular", new int[] {200, 80}, "premium", new int[] {350, 95}, "recliner", new int[] {600, 120}); // price in rupees, legroom in cm

    static String kindName(int row) { return row < 5 ? "recliner" : row < 15 ? "premium" : "regular"; } // rows 0-4 are recliners, rows 5-14 premium, the rest regular

    static final class Details { // what a kind of seat means: identical for every seat of that kind
        static int created = 0;
        final String name;
        final int price, legroom;

        Details(String name, int price, int legroom) {
            this.name = name;
            this.price = price;
            this.legroom = legroom;
            created++;
        }
    }

    static final class Seat {
        final int row, number;
        final Details details;

        Seat(int row, int number) {
            int[] spec = TABLE.get(kindName(row));
            this.row = row;
            this.number = number;
            this.details = new Details(kindName(row), spec[0], spec[1]); // a new copy for every seat
        }
    }

    public static void main(String[] args) {
        List<Seat> seats = new ArrayList<>();
        for (int row = 0; row < 40; row++) for (int number = 0; number < 50; number++) seats.add(new Seat(row, number));
        System.out.println("seats: " + seats.size());
        System.out.println("details objects: " + Details.created);
        System.out.println("two regular seats share their details: " + (seats.get(seats.size() - 1).details == seats.get(seats.size() - 2).details ? "yes" : "no"));
        Seat first = seats.get(0);
        System.out.println("row " + first.row + " seat " + first.number + ": " + first.details.name + ", " + first.details.price + " rupees, " + first.details.legroom + " cm");
    }
}

// seats_first_version.cpp: every seat builds its own copy of what its kind means
#include <iostream>
#include <map>
#include <string>
#include <utility>
#include <vector>

const std::map<std::string, std::pair<int, int>> TABLE = {{"regular", {200, 80}}, {"premium", {350, 95}}, {"recliner", {600, 120}}};  // price in rupees, legroom in cm

std::string kind_name(int row) { return row < 5 ? "recliner" : row < 15 ? "premium" : "regular"; }  // rows 0-4 are recliners, rows 5-14 premium, the rest regular

struct Details {  // what a kind of seat means: identical for every seat of that kind
    static int created;
    std::string name;
    int price, legroom;

    Details(std::string n, int p, int l) : name(std::move(n)), price(p), legroom(l) { ++created; }
};
int Details::created = 0;

struct Seat {
    int row, number;
    Details details;  // a new copy for every seat

    Seat(int r, int n) : row(r), number(n), details(kind_name(r), TABLE.at(kind_name(r)).first, TABLE.at(kind_name(r)).second) {}
};

int main() {
    std::vector<Seat> seats;
    seats.reserve(2000);
    for (int row = 0; row < 40; ++row)
        for (int number = 0; number < 50; ++number) seats.emplace_back(row, number);
    std::cout << "seats: " << seats.size() << "\n";
    std::cout << "details objects: " << Details::created << "\n";
    std::cout << "two regular seats share their details: " << (&seats[seats.size() - 1].details == &seats[seats.size() - 2].details ? "yes" : "no") << "\n";
    const Seat& first = seats[0];
    std::cout << "row " << first.row << " seat " << first.number << ": " << first.details.name << ", " << first.details.price << " rupees, " << first.details.legroom << " cm\n";
}

// seatsFirstVersion.js: every seat builds its own copy of what its kind means
const TABLE = { regular: [200, 80], premium: [350, 95], recliner: [600, 120] }; // price in rupees, legroom in cm

const kindName = (row) => (row < 5 ? "recliner" : row < 15 ? "premium" : "regular"); // rows 0-4 are recliners, rows 5-14 premium, the rest regular

let created = 0;

class Details { // what a kind of seat means: identical for every seat of that kind
  constructor(name, price, legroom) {
    Object.assign(this, { name, price, legroom });
    created++;
  }
}

class Seat {
  constructor(row, number) {
    const [price, legroom] = TABLE[kindName(row)];
    this.row = row;
    this.number = number;
    this.details = new Details(kindName(row), price, legroom); // a new copy for every seat
  }
}

const seats = [];
for (let row = 0; row < 40; row++) for (let number = 0; number < 50; number++) seats.push(new Seat(row, number));
console.log(`seats: ${seats.length}`);
console.log(`details objects: ${created}`);
console.log(`two regular seats share their details: ${seats[seats.length - 1].details === seats[seats.length - 2].details ? "yes" : "no"}`);
const first = seats[0];
console.log(`row ${first.row} seat ${first.number}: ${first.details.name}, ${first.details.price} rupees, ${first.details.legroom} cm`);

# flyweight.py: the shared part of a seat is one immutable SeatKind; where the seat is stays with the seat
from dataclasses import dataclass

TABLE = {"regular": (200, 80), "premium": (350, 95), "recliner": (600, 120)}  # price in rupees, legroom in cm


def kind_name(row: int) -> str:  # rows 0-4 are recliners, rows 5-14 premium, the rest regular
    return "recliner" if row < 5 else "premium" if row < 15 else "regular"


@dataclass(frozen=True)
class SeatKind:  # the flyweight: intrinsic state only, and it can't be changed
    name: str
    price: int
    legroom: int


class SeatKinds:  # the flyweight factory: one SeatKind per name, handed out again and again
    def __init__(self, table) -> None:
        self.table, self.made = table, {}

    def get(self, name: str) -> SeatKind:
        if name not in self.made:
            price, legroom = self.table[name]
            self.made[name] = SeatKind(name, price, legroom)
        return self.made[name]


class Seat:  # extrinsic state (where it is) lives here; the kind is only a reference
    def __init__(self, row: int, number: int, kind: SeatKind) -> None:
        self.row, self.number, self.kind = row, number, kind


class SeatMap:
    def __init__(self, rows: int, per_row: int, kinds: SeatKinds) -> None:
        self.seats = [Seat(r, n, kinds.get(kind_name(r))) for r in range(rows) for n in range(per_row)]
        self.sold = set()  # sold or not is extrinsic too: it differs per seat, so it stays outside the shared kind

    def sell(self, row: int, number: int) -> None:
        self.sold.add((row, number))

    def revenue(self) -> int:
        return sum(s.kind.price for s in self.seats if (s.row, s.number) in self.sold)


kinds = SeatKinds(TABLE)
seat_map = SeatMap(40, 50, kinds)
seats = seat_map.seats
print(f"seats: {len(seats)}")
print(f"kind objects: {len(kinds.made)}")
print(f"two regular seats share their kind: {'yes' if seats[-1].kind is seats[-2].kind else 'no'}")
first = seats[0]
print(f"row {first.row} seat {first.number}: {first.kind.name}, {first.kind.price} rupees, {first.kind.legroom} cm")
for row, number in ((0, 0), (0, 1), (10, 3), (20, 5)):
    seat_map.sell(row, number)
print(f"sold {len(seat_map.sold)} seats, revenue {seat_map.revenue()}")

// Flyweight.java: the shared part of a seat is one immutable SeatKind; where the seat is stays with the seat
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

class Flyweight {
    static final Map<String, int[]> TABLE = Map.of("regular", new int[] {200, 80}, "premium", new int[] {350, 95}, "recliner", new int[] {600, 120}); // price in rupees, legroom in cm

    static String kindName(int row) { return row < 5 ? "recliner" : row < 15 ? "premium" : "regular"; } // rows 0-4 are recliners, rows 5-14 premium, the rest regular

    record SeatKind(String name, int price, int legroom) {} // the flyweight: intrinsic state only, and a record can't be changed

    static final class SeatKinds { // the flyweight factory: one SeatKind per name, handed out again and again
        private final Map<String, int[]> table;
        private final Map<String, SeatKind> made = new HashMap<>();

        SeatKinds(Map<String, int[]> table) { this.table = table; }

        SeatKind get(String name) { return made.computeIfAbsent(name, n -> new SeatKind(n, table.get(n)[0], table.get(n)[1])); }

        int made() { return made.size(); }
    }

    record Seat(int row, int number, SeatKind kind) {} // extrinsic state (where it is) lives here; the kind is only a reference

    static final class SeatMap {
        final List<Seat> seats = new ArrayList<>();
        final Set<String> sold = new HashSet<>(); // sold or not is extrinsic too: it differs per seat, so it stays outside the shared kind

        SeatMap(int rows, int perRow, SeatKinds kinds) {
            for (int r = 0; r < rows; r++) for (int n = 0; n < perRow; n++) seats.add(new Seat(r, n, kinds.get(kindName(r))));
        }

        void sell(int row, int number) { sold.add(row + ":" + number); }

        int revenue() {
            int total = 0;
            for (Seat s : seats) if (sold.contains(s.row() + ":" + s.number())) total += s.kind().price();
            return total;
        }
    }

    public static void main(String[] args) {
        SeatKinds kinds = new SeatKinds(TABLE);
        SeatMap seatMap = new SeatMap(40, 50, kinds);
        List<Seat> seats = seatMap.seats;
        System.out.println("seats: " + seats.size());
        System.out.println("kind objects: " + kinds.made());
        System.out.println("two regular seats share their kind: " + (seats.get(seats.size() - 1).kind() == seats.get(seats.size() - 2).kind() ? "yes" : "no"));
        Seat first = seats.get(0);
        System.out.println("row " + first.row() + " seat " + first.number() + ": " + first.kind().name() + ", " + first.kind().price() + " rupees, " + first.kind().legroom() + " cm");
        int[][] sales = {{0, 0}, {0, 1}, {10, 3}, {20, 5}};
        for (int[] s : sales) seatMap.sell(s[0], s[1]);
        System.out.println("sold " + seatMap.sold.size() + " seats, revenue " + seatMap.revenue());
    }
}

// flyweight.cpp: the shared part of a seat is one immutable SeatKind; where the seat is stays with the seat
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <utility>
#include <vector>

const std::map<std::string, std::pair<int, int>> TABLE = {{"regular", {200, 80}}, {"premium", {350, 95}}, {"recliner", {600, 120}}};  // price in rupees, legroom in cm

std::string kind_name(int row) { return row < 5 ? "recliner" : row < 15 ? "premium" : "regular"; }  // rows 0-4 are recliners, rows 5-14 premium, the rest regular

struct SeatKind {  // the flyweight: intrinsic state only, and every member is const
    const std::string name;
    const int price;
    const int legroom;
};

class SeatKinds {  // the flyweight factory: one SeatKind per name, handed out again and again
    std::map<std::string, std::pair<int, int>> table_;
    std::map<std::string, SeatKind> made_;  // map nodes never move, so a pointer to one stays valid

public:
    explicit SeatKinds(std::map<std::string, std::pair<int, int>> table) : table_(std::move(table)) {}

    const SeatKind* get(const std::string& name) {
        auto it = made_.find(name);
        if (it == made_.end()) it = made_.emplace(name, SeatKind{name, table_.at(name).first, table_.at(name).second}).first;
        return &it->second;
    }

    size_t made() const { return made_.size(); }
};

struct Seat {  // extrinsic state (where it is) lives here; the kind is only a pointer
    int row, number;
    const SeatKind* kind;
};

class SeatMap {
public:
    std::vector<Seat> seats;
    std::set<std::pair<int, int>> sold;  // sold or not is extrinsic too: it differs per seat, so it stays outside the shared kind

    SeatMap(int rows, int per_row, SeatKinds& kinds) {
        for (int r = 0; r < rows; ++r)
            for (int n = 0; n < per_row; ++n) seats.push_back({r, n, kinds.get(kind_name(r))});
    }

    void sell(int row, int number) { sold.insert({row, number}); }

    int revenue() const {
        int total = 0;
        for (const Seat& s : seats)
            if (sold.count({s.row, s.number})) total += s.kind->price;
        return total;
    }
};

int main() {
    SeatKinds kinds(TABLE);
    SeatMap seat_map(40, 50, kinds);
    const std::vector<Seat>& seats = seat_map.seats;
    std::cout << "seats: " << seats.size() << "\n";
    std::cout << "kind objects: " << kinds.made() << "\n";
    std::cout << "two regular seats share their kind: " << (seats[seats.size() - 1].kind == seats[seats.size() - 2].kind ? "yes" : "no") << "\n";
    const Seat& first = seats[0];
    std::cout << "row " << first.row << " seat " << first.number << ": " << first.kind->name << ", " << first.kind->price << " rupees, " << first.kind->legroom << " cm\n";
    for (auto [row, number] : {std::pair<int, int>{0, 0}, {0, 1}, {10, 3}, {20, 5}}) seat_map.sell(row, number);
    std::cout << "sold " << seat_map.sold.size() << " seats, revenue " << seat_map.revenue() << "\n";
}

// flyweight.js: the shared part of a seat is one immutable SeatKind; where the seat is stays with the seat
const TABLE = { regular: [200, 80], premium: [350, 95], recliner: [600, 120] }; // price in rupees, legroom in cm

const kindName = (row) => (row < 5 ? "recliner" : row < 15 ? "premium" : "regular"); // rows 0-4 are recliners, rows 5-14 premium, the rest regular

class SeatKinds { // the flyweight factory: one frozen SeatKind per name, handed out again and again
  constructor(table) {
    this.table = table;
    this.made = new Map();
  }

  get(name) {
    if (!this.made.has(name)) {
      const [price, legroom] = this.table[name];
      this.made.set(name, Object.freeze({ name, price, legroom })); // the flyweight: intrinsic state only, and frozen
    }
    return this.made.get(name);
  }
}

class Seat { // extrinsic state (where it is) lives here; the kind is only a reference
  constructor(row, number, kind) {
    Object.assign(this, { row, number, kind });
  }
}

class SeatMap {
  constructor(rows, perRow, kinds) {
    this.seats = [];
    for (let r = 0; r < rows; r++) for (let n = 0; n < perRow; n++) this.seats.push(new Seat(r, n, kinds.get(kindName(r))));
    this.sold = new Set(); // sold or not is extrinsic too: it differs per seat, so it stays outside the shared kind
  }

  sell(row, number) { this.sold.add(`${row}:${number}`); }

  revenue() { return this.seats.filter((s) => this.sold.has(`${s.row}:${s.number}`)).reduce((sum, s) => sum + s.kind.price, 0); }
}

const kinds = new SeatKinds(TABLE);
const seatMap = new SeatMap(40, 50, kinds);
const seats = seatMap.seats;
console.log(`seats: ${seats.length}`);
console.log(`kind objects: ${kinds.made.size}`);
console.log(`two regular seats share their kind: ${seats[seats.length - 1].kind === seats[seats.length - 2].kind ? "yes" : "no"}`);
const first = seats[0];
console.log(`row ${first.row} seat ${first.number}: ${first.kind.name}, ${first.kind.price} rupees, ${first.kind.legroom} cm`);
for (const [row, number] of [[0, 0], [0, 1], [10, 3], [20, 5]]) seatMap.sell(row, number);
console.log(`sold ${seatMap.sold.size} seats, revenue ${seatMap.revenue()}`);

# shared_state.py: a mutable flyweight is shared by 1,250 seats, so one change reaches all of them
class Kind:  # not frozen: that is the bug
    def __init__(self, name: str, price: int) -> None:
        self.name, self.price = name, price


regular = Kind("regular", 200)
seats = [(row, number, regular) for row in range(25) for number in range(50)]  # 1,250 regular seats share one kind
seats[0][2].price = 100  # "an offer for this one seat"
print(f"mutable kind: seats at 100 after one offer: {sum(1 for s in seats if s[2].price == 100)}")

kind = Kind("regular", 200)  # fresh again, and this time it is never changed
offers = {(0, 0): 100}  # a per-seat exception is extrinsic: it is kept outside the shared kind


def price_of(row: int, number: int) -> int:
    return offers.get((row, number), kind.price)


at_100 = sum(1 for row in range(25) for number in range(50) if price_of(row, number) == 100)
print(f"extrinsic offer: seats at 100: {at_100}, the kind still costs {kind.price}")

// SharedState.java: a mutable flyweight is shared by 1,250 seats, so one change reaches all of them
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

class SharedState {
    static final class Kind { // price isn't final: that is the bug
        final String name;
        int price;

        Kind(String name, int price) {
            this.name = name;
            this.price = price;
        }
    }

    record Seat(int row, int number, Kind kind) {}

    public static void main(String[] args) {
        Kind regular = new Kind("regular", 200);
        List<Seat> seats = new ArrayList<>();
        for (int row = 0; row < 25; row++) for (int number = 0; number < 50; number++) seats.add(new Seat(row, number, regular)); // 1,250 regular seats share one kind
        seats.get(0).kind().price = 100; // "an offer for this one seat"
        System.out.println("mutable kind: seats at 100 after one offer: " + seats.stream().filter(s -> s.kind().price == 100).count());

        Kind kind = new Kind("regular", 200); // fresh again, and this time it is never changed
        Map<String, Integer> offers = new HashMap<>();
        offers.put("0:0", 100); // a per-seat exception is extrinsic: it is kept outside the shared kind
        int at100 = 0;
        for (int row = 0; row < 25; row++) for (int number = 0; number < 50; number++) if (offers.getOrDefault(row + ":" + number, kind.price) == 100) at100++;
        System.out.println("extrinsic offer: seats at 100: " + at100 + ", the kind still costs " + kind.price);
    }
}

// shared_state.cpp: a mutable flyweight is shared by 1,250 seats, so one change reaches all of them
#include <iostream>
#include <map>
#include <string>
#include <utility>
#include <vector>

struct Kind {  // not const: that is the bug
    std::string name;
    int price;
};

struct Seat {
    int row, number;
    Kind* kind;  // a non-const pointer lets any seat change the shared kind
};

int main() {
    Kind regular{"regular", 200};
    std::vector<Seat> seats;
    for (int row = 0; row < 25; ++row)
        for (int number = 0; number < 50; ++number) seats.push_back({row, number, &regular});  // 1,250 regular seats share one kind
    seats[0].kind->price = 100;  // "an offer for this one seat"
    int shared = 0;
    for (const Seat& s : seats) shared += s.kind->price == 100;
    std::cout << "mutable kind: seats at 100 after one offer: " << shared << "\n";

    Kind kind{"regular", 200};  // fresh again, and this time it is never changed
    std::map<std::pair<int, int>, int> offers = {{{0, 0}, 100}};  // a per-seat exception is extrinsic: it is kept outside the shared kind
    int at_100 = 0;
    for (int row = 0; row < 25; ++row)
        for (int number = 0; number < 50; ++number) {
            auto it = offers.find({row, number});
            at_100 += (it != offers.end() ? it->second : kind.price) == 100;
        }
    std::cout << "extrinsic offer: seats at 100: " << at_100 << ", the kind still costs " << kind.price << "\n";
}

// sharedState.js: a mutable flyweight is shared by 1,250 seats, so one change reaches all of them
class Kind { // not frozen: that is the bug
  constructor(name, price) {
    this.name = name;
    this.price = price;
  }
}

const regular = new Kind("regular", 200);
const seats = [];
for (let row = 0; row < 25; row++) for (let number = 0; number < 50; number++) seats.push({ row, number, kind: regular }); // 1,250 regular seats share one kind
seats[0].kind.price = 100; // "an offer for this one seat"
console.log(`mutable kind: seats at 100 after one offer: ${seats.filter((s) => s.kind.price === 100).length}`);

const kind = new Kind("regular", 200); // fresh again, and this time it is never changed
const offers = new Map([["0:0", 100]]); // a per-seat exception is extrinsic: it is kept outside the shared kind
let at100 = 0;
for (let row = 0; row < 25; row++) for (let number = 0; number < 50; number++) if ((offers.get(`${row}:${number}`) ?? kind.price) === 100) at100++;
console.log(`extrinsic offer: seats at 100: ${at100}, the kind still costs ${kind.price}`);