library_example.cpp

#include <algorithm>
#include <cstdint>
#include <iostream>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <vector>

#include "delegate.hpp"

class Library;
class CollectionBase;

class CatalogItem {
 public:
  explicit CatalogItem(std::uint64_t id) : id_(id) {}
  virtual ~CatalogItem() = default;

  std::uint64_t id() const { return id_; }
  Library* library() const { return library_; }

  virtual std::string description() const = 0;

 private:
  std::uint64_t id_{0};
  Library* library_{nullptr};

  friend class Library;
};

struct CollectionEvent {
  const CollectionBase* sender{nullptr};
  CatalogItem* item{nullptr};
};

class CollectionBase {
 public:
  using EventSignal = Delegate<void(const CollectionEvent&)>;

  virtual ~CollectionBase() = default;

  EventSignal added;
  EventSignal removed;

  virtual const std::string& name() const = 0;
  virtual std::vector<CatalogItem*> snapshot() const = 0;
};

template <typename T>
class ObservableCollection : public CollectionBase {
 public:
  static_assert(std::is_base_of_v<CatalogItem, T>, "T must derive from CatalogItem");
  virtual ~ObservableCollection() = default;

  virtual bool add(std::unique_ptr<T> item) {
    if (!item) {
      std::cout << "[ObservableCollection] null item, skip" << '\n';
      return false;
    }

    T* raw_item = item.get();
    items_.push_back(std::move(item));
    added.broadcast(CollectionEvent{this, raw_item});
    return true;
  }

  const std::vector<std::unique_ptr<T>>& items() const { return items_; }

  std::vector<CatalogItem*> snapshot() const override {
    std::vector<CatalogItem*> items;
    items.reserve(items_.size());
    for (const std::unique_ptr<T>& item : items_) {
      items.push_back(item.get());
    }
    return items;
  }

 protected:
  template <typename Predicate>
  bool contains_if(Predicate&& predicate) const {
    return std::any_of(items_.begin(), items_.end(),
                       [&predicate](const std::unique_ptr<T>& item) { return predicate(*item); });
  }

  template <typename Predicate>
  bool erase_if(Predicate&& predicate) {
    auto it = std::find_if(items_.begin(), items_.end(),
                           [&predicate](const std::unique_ptr<T>& item) { return predicate(*item); });
    if (it == items_.end()) {
      return false;
    }

    std::unique_ptr<T> removed_item = std::move(*it);
    items_.erase(it);
    removed.broadcast(CollectionEvent{this, removed_item.get()});
    return true;
  }

 private:
  std::vector<std::unique_ptr<T>> items_;
};

class Book : public CatalogItem {
 public:
  Book(std::uint64_t id, std::string title) : CatalogItem(id), title_(std::move(title)) {}

  const std::string& title() const { return title_; }

  std::string description() const override { return std::to_string(id()) + " - " + title_; }

 private:
  std::string title_;
};

class Magazine : public CatalogItem {
 public:
  Magazine(std::uint64_t id, std::string name, int issue) : CatalogItem(id), name_(std::move(name)), issue_(issue) {}

  std::string description() const override {
    return std::to_string(id()) + " - " + name_ + " (issue " + std::to_string(issue_) + ")";
  }

 private:
  std::string name_;
  int issue_{0};
};

class BookShelf : public ObservableCollection<Book> {
 public:
  explicit BookShelf(std::string name) : name_(std::move(name)) {}

  bool add(std::unique_ptr<Book> book) override {
    if (book && contains_id(book->id())) {
      std::cout << "[BookShelf] duplicate id, skip: " << book->id() << '\n';
      return false;
    }

    return ObservableCollection<Book>::add(std::move(book));
  }

  bool add_book(std::uint64_t id, std::string title) { return add(std::make_unique<Book>(id, std::move(title))); }

  bool remove_book(std::uint64_t id) {
    if (!this->erase_if([id](const Book& book) { return book.id() == id; })) {
      std::cout << "[BookShelf] missing id, skip remove: " << id << '\n';
      return false;
    }

    return true;
  }

  const std::string& name() const override { return name_; }

 private:
  bool contains_id(std::uint64_t id) const {
    return this->contains_if([id](const Book& book) { return book.id() == id; });
  }

  std::string name_;
};

class MagazineRack : public ObservableCollection<Magazine> {
 public:
  explicit MagazineRack(std::string name) : name_(std::move(name)) {}

  bool add(std::unique_ptr<Magazine> magazine) override {
    if (magazine && contains_id(magazine->id())) {
      std::cout << "[MagazineRack] duplicate id, skip: " << magazine->id() << '\n';
      return false;
    }

    return ObservableCollection<Magazine>::add(std::move(magazine));
  }

  bool add_magazine(std::uint64_t id, std::string name, int issue) {
    return add(std::make_unique<Magazine>(id, std::move(name), issue));
  }

  bool remove_magazine(std::uint64_t id) {
    if (!this->erase_if([id](const Magazine& magazine) { return magazine.id() == id; })) {
      std::cout << "[MagazineRack] missing id, skip remove: " << id << '\n';
      return false;
    }

    return true;
  }

  const std::string& name() const override { return name_; }

 private:
  bool contains_id(std::uint64_t id) const {
    return this->contains_if([id](const Magazine& magazine) { return magazine.id() == id; });
  }

  std::string name_;
};

class Library {
 public:
  template <typename T>
  void register_collection(ObservableCollection<T>& collection) {
    auto* base = static_cast<CollectionBase*>(&collection);
    if (subscriptions_.count(base) != 0) {
      std::cout << "[Library] collection already registered: " << base->name() << '\n';
      return;
    }

    Subscription subscription;
    subscription.add_handle = base->added.add(this, &Library::handle_add);
    subscription.remove_handle = base->removed.add(this, &Library::handle_remove);
    subscriptions_.emplace(base, subscription);

    std::cout << "[Library] register_collection: " << base->name() << '\n';

    for (CatalogItem* item : base->snapshot()) {
      load_existing_item(*base, *item);
    }

    print_index_size();
  }

  template <typename T>
  void unregister_collection(ObservableCollection<T>& collection) {
    auto* base = static_cast<CollectionBase*>(&collection);
    auto it = subscriptions_.find(base);
    if (it == subscriptions_.end()) {
      std::cout << "[Library] collection is not registered: " << base->name() << '\n';
      return;
    }

    base->added.remove(it->second.add_handle);
    base->removed.remove(it->second.remove_handle);
    subscriptions_.erase(it);

    std::cout << "[Library] unregister_collection: " << base->name() << '\n';

    for (CatalogItem* item : base->snapshot()) {
      remove_item(*base, *item, "remove because collection was unregistered");
    }

    print_index_size();
  }

 private:
  using EventSignal = CollectionBase::EventSignal;

  struct Subscription {
    EventSignal::Handle add_handle{EventSignal::InvalidHandle};
    EventSignal::Handle remove_handle{EventSignal::InvalidHandle};
  };

  struct IndexEntry {
    std::string collection_name;
    std::string description;
  };

  void load_existing_item(const CollectionBase& collection, CatalogItem& item) {
    add_item(collection, item, "load existing item");
  }

  void handle_add(const CollectionEvent& event) {
    if (!event.sender || !event.item) {
      return;
    }

    add_item(*event.sender, *event.item, "noticed added");
    print_index_size();
  }

  void handle_remove(const CollectionEvent& event) {
    if (!event.sender || !event.item) {
      return;
    }

    remove_item(*event.sender, *event.item, "noticed removed");
    print_index_size();
  }

  void add_item(const CollectionBase& collection, CatalogItem& item, const std::string& reason) {
    if (item.library_ != nullptr && item.library_ != this) {
      std::cout << "[Library] item already belongs to another library: " << item.description() << '\n';
      return;
    }

    item.library_ = this;
    index_[item.id()] = IndexEntry{collection.name(), item.description()};
    std::cout << "[Library] " << reason << " from " << collection.name() << ": " << item.description() << '\n';
  }

  void remove_item(const CollectionBase& collection, CatalogItem& item, const std::string& reason) {
    auto it = index_.find(item.id());
    if (it == index_.end()) {
      return;
    }

    item.library_ = nullptr;
    std::cout << "[Library] " << reason << " from " << collection.name() << ": " << item.description() << '\n';
    index_.erase(it);
  }

  void print_index_size() const { std::cout << "[Library] indexed item count: " << index_.size() << '\n'; }

  std::unordered_map<CollectionBase*, Subscription> subscriptions_;
  std::unordered_map<std::uint64_t, IndexEntry> index_;
};

int main() {
  BookShelf shelf("Fiction Shelf");
  shelf.add_book(101, "Dune");
  shelf.add_book(102, "Foundation");

  MagazineRack rack("Magazine Rack");
  rack.add_magazine(201, "Science Weekly", 42);
  rack.add_magazine(202, "Tech Monthly", 7);

  Library library;

  std::cout << "--- Register book collection after it already has data ---" << '\n';
  library.register_collection(shelf);

  std::cout << '\n' << "--- Register magazine collection after it already has data ---" << '\n';
  library.register_collection(rack);

  std::cout << '\n' << "--- Add one more book after registration ---" << '\n';
  shelf.add_book(103, "Hyperion");

  std::cout << '\n' << "--- Try duplicate book id, derived class should reject it ---" << '\n';
  shelf.add(std::make_unique<Book>(103, "Duplicate Hyperion"));

  std::cout << '\n' << "--- Add one more magazine after registration ---" << '\n';
  rack.add_magazine(203, "History Digest", 3);

  std::cout << '\n' << "--- Remove one book after registration ---" << '\n';
  shelf.remove_book(102);

  std::cout << '\n' << "--- Remove one magazine after registration ---" << '\n';
  rack.remove_magazine(201);

  std::cout << '\n' << "--- Unregister book collection ---" << '\n';
  library.unregister_collection(shelf);

  std::cout << '\n' << "--- Add book after unregister, Library should stay silent for books ---" << '\n';
  shelf.add_book(104, "Snow Crash");

  std::cout << '\n' << "--- Magazine collection is still registered ---" << '\n';
  rack.add_magazine(204, "Design Review", 11);

  std::cout << '\n' << "--- Unregister magazine collection ---" << '\n';
  library.unregister_collection(rack);

  return 0;
}