Factory Method

interface ReportWriter {
    fun write(rows: List<List<String>>): ByteArray
}

abstract class ReportExporter {
    protected abstract fun makeWriter(): ReportWriter    // the factory method

    fun export(rows: List<List<String>>): ByteArray {    // the shared routine
        val writer = makeWriter()
        return writer.write(rows)
    }
}

class CsvExporter : ReportExporter() {
    override fun makeWriter(): ReportWriter = CsvWriter()
}

class JsonExporter : ReportExporter() {
    override fun makeWriter(): ReportWriter = JsonWriter()
}

interface ReportWriter {
    byte[] write(List<List<String>> rows);
}

abstract class ReportExporter {
    protected abstract ReportWriter makeWriter();        // the factory method

    public final byte[] export(List<List<String>> rows) { // the shared routine
        ReportWriter writer = makeWriter();
        return writer.write(rows);
    }
}

final class CsvExporter extends ReportExporter {
    @Override protected ReportWriter makeWriter() { return new CsvWriter(); }
}

final class JsonExporter extends ReportExporter {
    @Override protected ReportWriter makeWriter() { return new JsonWriter(); }
}

interface ReportWriter {
  write(rows: string[][]): Uint8Array;
}

abstract class ReportExporter {
  protected abstract makeWriter(): ReportWriter;          // the factory method

  export(rows: string[][]): Uint8Array {                  // the shared routine
    const writer = this.makeWriter();
    return writer.write(rows);
  }
}

class CsvExporter extends ReportExporter {
  protected makeWriter(): ReportWriter { return new CsvWriter(); }
}

class JsonExporter extends ReportExporter {
  protected makeWriter(): ReportWriter { return new JsonWriter(); }
}

class SenderRegistry {
    private val makers = mutableMapOf<String, () -> NotificationSender>()

    fun register(channel: String, make: () -> NotificationSender) {
        check(channel !in makers) { "Channel $channel registered twice" }
        makers[channel] = make
    }

    fun sender(channel: String): NotificationSender =
        makers[channel]?.invoke() ?: throw IllegalArgumentException("Unknown channel $channel")
}

registry.register("whatsapp") { WhatsAppSender(config.whatsAppToken) }   // in the WhatsApp module

final class SenderRegistry {
    private final Map<String, Supplier<NotificationSender>> makers = new ConcurrentHashMap<>();

    void register(String channel, Supplier<NotificationSender> make) {
        if (makers.putIfAbsent(channel, make) != null)
            throw new IllegalStateException("Channel " + channel + " registered twice");
    }

    NotificationSender sender(String channel) {
        Supplier<NotificationSender> make = makers.get(channel);
        if (make == null) throw new IllegalArgumentException("Unknown channel " + channel);
        return make.get();
    }
}

registry.register("whatsapp", () -> new WhatsAppSender(config.whatsAppToken()));   // in the WhatsApp module

class SenderRegistry {
  private readonly makers = new Map<string, () => NotificationSender>();

  register(channel: string, make: () => NotificationSender): void {
    if (this.makers.has(channel)) throw new Error(`Channel ${channel} registered twice`);
    this.makers.set(channel, make);
  }

  sender(channel: string): NotificationSender {
    const make = this.makers.get(channel);
    if (!make) throw new Error(`Unknown channel ${channel}`);
    return make();
  }
}

registry.register("whatsapp", () => new WhatsAppSender(config.whatsAppToken));   // in the WhatsApp module