event.inl

#pragma once
#include "event.hpp"
#include "toast/log.hpp"
 
#include <mutex>
#include <tracy/Tracy.hpp>
#include <type_traits>
 
namespace event {
struct InspectorContent;
struct InspectorLuaContent;
 
template<typename T>
void Event<T>::ensureRegistered() noexcept {
  static const bool registered = [] {
    EventSystem::registerEvent<T>();
    return true;
  }();
  (void)registered;
}
 
template<typename T>
auto EventSystem::info() noexcept -> EventInfo& {
  Event<T>::ensureRegistered();
  static EventInfo& cached = []() -> EventInfo& {
    std::shared_lock lock(registration_mutex);
    return event_data.at(std::type_index(typeid(T)));
  }();
  return cached;
}
 
template<typename T>
auto Event<T>::subscribe(char priority, callback_t&& callback) noexcept -> iterator_t {
  ensureRegistered();
 
  auto cb = new callback_t(std::move(callback));
  auto& g = EventSystem::info<T>();
  {
    std::scoped_lock _(g.mutex);
    g.cached = false;
    return g.callbacks.emplace(priority, static_cast<void*>(cb));
  }
}
 
template<typename T>
void Event<T>::unsubscribe(iterator_t it) noexcept {
  ensureRegistered();
 
  auto& g = EventSystem::info<T>();
  {
    std::scoped_lock _(EventSystem::deletion_mutex);
    auto deleter = [](void* p) { delete static_cast<std::move_only_function<bool(T&)>*>(p); };
    EventSystem::deletion_queue.emplace_back((*it).second, deleter);
  }
  {
    std::scoped_lock _(g.mutex);
    g.cached = false;
    g.callbacks.erase(it);
  }
}
 
template<typename T>
void Event<T>::notify() noexcept {
  ZoneScoped;
 
  ensureRegistered();
 
  auto& g = EventSystem::info<T>();
  {
    // build cached list of all the callbacks in order
    // locks mutex for the shortest period possible
    // improves cache locality
    std::scoped_lock _(g.mutex);
    if (not g.cached) {
      g.cached = true;
      g.processing.clear();
      for (auto& [priority, callback] : g.callbacks) {
        g.processing.emplace_back(callback);
      }
    }
  }
 
  // disptaches all of the callbacks
  for (auto& callback : g.processing) {
    ZoneScopedN("Callback dispatch");
 
    bool handled = (*static_cast<callback_t*>(callback))(static_cast<T&>(*this));
    if (handled) {
      return;
    }
  }
}
 
template<typename T, typename... Args>
  requires std::is_base_of_v<_detail::IEvent, T>
void send(Args&&... args) noexcept {
  ZoneScoped;
 
  static_assert(std::is_constructible_v<T, Args...>, "Invalid Construtor For Type T");
  if constexpr (
      !std::is_same_v<std::decay_t<T>, event::InspectorContent> && !std::is_same_v<std::decay_t<T>, event::InspectorLuaContent>
  ) {
    // im going to disable this for now
    // TOAST_TRACE("Events", "Sending event: {}", typeid(T).name());
  }
 
  // Allocate and enqueue event
  {
    std::scoped_lock _(EventSystem::pool_mutex);
    void* memory = _detail::allocate(sizeof(T), alignof(T));
    assert(memory);
    _detail::IEvent* event = new (memory) T(std::forward<Args>(args)...);
#ifdef DEBUG
    // TODO: event->stacktrace = std::stacktrace::current(1);
#endif
  }
}
 
}