event.hpp

#pragma once
 
#include <any>
#include <functional>
#include <map>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <toast/export.hpp>
#include <toast/log.hpp>
#include <type_traits>
#include <typeindex>
#include <vector>
 
namespace event {

void TOAST_API pollEvents() noexcept;

namespace _detail {
struct TOAST_API IEvent {
  virtual ~IEvent() = default;
 
#ifdef DEBUG
  // std::stacktrace stacktrace;
#endif
 
private:
  friend void TOAST_API event::pollEvents() noexcept;
  virtual void notify() noexcept = 0;
};

auto TOAST_API allocate(std::size_t size, std::size_t align) noexcept -> void*;
}

template<typename T, typename... Args>
  requires std::is_base_of_v<_detail::IEvent, T>
void send(Args&&... args) noexcept;

template<typename T>
struct Event : _detail::IEvent {
  friend class Listener;
  friend class ThreadListener;
  friend struct EventSystem;
  friend T;
  using callback_t = std::move_only_function<bool(T&)>;
  using iterator_t = std::multimap<char, void*, std::greater<>>::iterator;
 
private:
  Event() = default;
 
  static void ensureRegistered() noexcept;

  static auto subscribe(char priority, callback_t&& callback) noexcept -> iterator_t;

  static void unsubscribe(iterator_t it) noexcept;

  void notify() noexcept override;
};

struct TOAST_API EventSystem {
  struct EventInfo {
    std::mutex mutex;
    std::multimap<char, void*, std::greater<>> callbacks;
    std::vector<void*> processing;
    bool cached = false;
  };

  static std::unordered_map<std::type_index, EventInfo> event_data;

  static std::shared_mutex registration_mutex;

  static void unsubscribeAny(std::type_index type, const std::any& iterator);
 
  template<typename T>
  static auto info() noexcept -> EventInfo&;

  static std::mutex pool_mutex;

  static std::unordered_map<std::type_index, std::function<void(std::any)>> unsubscribe_map;

  static std::vector<std::unique_ptr<void, void (*)(void*)>> deletion_queue;

  static std::mutex deletion_mutex;
 
  template<typename T>
  static void registerEvent() {
    static_assert(std::is_base_of_v<Event<T>, T>, "CONTRACT VIOLATION: You Must Inhert as 'struct Derived : Event<Derived>'");
    std::unique_lock registration_lock(registration_mutex);
    if (event_data.contains(typeid(T))) {
      // guard against cross-DLL double-registration; same type can be registered from multiple translation units on Windows
      return;
    }
    TOAST_INFO("Events", "Registering Event Type: {}", typeid(T).name());
    event_data.emplace( // this is goofy because eventinfo has a mutex inside it
        std::piecewise_construct,
        std::forward_as_tuple(typeid(T)),
        std::forward_as_tuple()
    );
 
    EventSystem::unsubscribe_map.emplace(typeid(T), [](const std::any& iter) {
      auto it = std::any_cast<typename Event<T>::iterator_t>(iter);
      Event<T>::unsubscribe(it);
    });
  }
};

template<typename T>
struct ProtoTraits;

template<typename T>
concept ExposedEvent = requires(const T& e, const typename ProtoTraits<T>::Proto& p) {
  typename ProtoTraits<T>::Proto;
  typename ProtoTraits<T>::Event;
  { ProtoTraits<T>::toProto(e) } -> std::same_as<typename ProtoTraits<T>::Proto>;
  { ProtoTraits<T>::fromProto(p) } -> std::same_as<typename ProtoTraits<T>::Event>;
};
 
// register all exposed events into a registry
void registerProtoEvents();
 
}
 
#include "event.inl"