EventBus.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <cstdint>
#include <functional>
#include <memory>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <vector>
 
using HandlerId = uint32_t;
 
class IEventQueue {
public:
  virtual ~IEventQueue() = default;
 
  virtual void Dispatch() = 0;
 
  virtual void RemoveHandler(HandlerId id) = 0;
};
 
template <typename T>
class EventQueue : public IEventQueue {
public:
  std::vector<T> queue;  
  std::vector<std::pair<HandlerId, std::function<void(const T&)>>>
    handlers;  
 
  void Dispatch() override {
    if (queue.empty())
      return;
 
    auto currentEvents = std::move(queue);
    queue.clear();
 
    for (const auto& event : currentEvents) {
      for (const auto& handlerPair : handlers) {
        handlerPair.second(event);
      }
    }
  }
 
  void RemoveHandler(HandlerId id) override {
    // std::remove_if moves elements to be deleted to the end, then erase removes them
    auto it = std::remove_if(handlers.begin(), handlers.end(),
                             [id](const auto& pair) { return pair.first == id; });
 
    if (it != handlers.end()) {
      handlers.erase(it, handlers.end());
    }
  }
};
 
class EventBus {
private:
  std::unordered_map<std::type_index, std::unique_ptr<IEventQueue>>
    queues;          
  HandlerId nextId;  
 
public:
  EventBus() : nextId(0) {
  }
 
  template <typename T>
  void Publish(T&& event) {
    using CleanType = std::decay_t<T>;
    auto typeIdx    = std::type_index(typeid(CleanType));
 
    if (queues.find(typeIdx) == queues.end()) {
      queues[typeIdx] = std::make_unique<EventQueue<CleanType>>();
    }
 
    auto* q = static_cast<EventQueue<CleanType>*>(queues[typeIdx].get());
    q->queue.push_back(std::forward<T>(event));
  }
 
  template <typename T>
  HandlerId Subscribe(std::function<void(const T&)> callback) {
    using CleanType = std::decay_t<T>;
    auto typeIdx    = std::type_index(typeid(CleanType));
 
    if (queues.find(typeIdx) == queues.end()) {
      queues[typeIdx] = std::make_unique<EventQueue<CleanType>>();
    }
 
    auto* q = static_cast<EventQueue<CleanType>*>(queues[typeIdx].get());
 
    HandlerId id = ++nextId;
    q->handlers.push_back({id, callback});
 
    return id;
  }
 
  void Unsubscribe(HandlerId id) {
    for (auto& [type, q] : queues) {
      q->RemoveHandler(id);
    }
  }
 
  void DispatchEvents() {
    for (auto& [type, q] : queues) {
      q->Dispatch();
    }
  }
};