event_bus.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_REGISTRY_EVENT_BUS_H_
#define YAZE_APP_EDITOR_REGISTRY_EVENT_BUS_H_
 
#include <algorithm>
#include <functional>
#include <memory>
#include <typeindex>
#include <unordered_map>
#include <vector>
 
namespace yaze {
 
struct Event {
  virtual ~Event() = default;
};
 
class EventBus {
 public:
  using HandlerId = size_t;
 
  template <typename T>
  HandlerId Subscribe(std::function<void(const T&)> handler) {
    static_assert(std::is_base_of<Event, T>::value, "T must derive from Event");
    auto type_idx = std::type_index(typeid(T));
    auto wrapper = [handler](const Event& e) {
      handler(static_cast<const T&>(e));
    };
 
    size_t id = next_id_++;
    handlers_[type_idx].push_back({id, wrapper});
    return id;
  }
 
  template <typename T>
  void Publish(const T& event) {
    static_assert(std::is_base_of<Event, T>::value, "T must derive from Event");
    auto type_idx = std::type_index(typeid(T));
    if (handlers_.find(type_idx) != handlers_.end()) {
      for (const auto& handler : handlers_[type_idx]) {
        handler.fn(event);
      }
    }
  }
 
  void Unsubscribe(HandlerId id) {
    for (auto& [type, list] : handlers_) {
      auto it = std::remove_if(
          list.begin(), list.end(),
          [id](const HandlerEntry& entry) { return entry.id == id; });
      if (it != list.end()) {
        list.erase(it, list.end());
        return;
      }
    }
  }
 
 private:
  struct HandlerEntry {
    HandlerId id;
    std::function<void(const Event&)> fn;
  };
 
  std::unordered_map<std::type_index, std::vector<HandlerEntry>> handlers_;
  HandlerId next_id_ = 1;
};
 
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_REGISTRY_EVENT_BUS_H_