listener.hpp

#pragma once
 
#include "event.hpp"
 
#include <any>
#include <cassert>
#include <string>
#include <string_view>
#include <type_traits>
#include <typeindex>
#include <vector>
 
namespace event {

template<typename F, typename TEvent>
concept EventCallback = std::is_invocable_r_v<bool, F, TEvent&> ||    // Returns bool(T&)
                        std::is_invocable_r_v<void, F, TEvent&> ||    // Returns void(T&)
                        std::is_invocable_r_v<bool, F> ||             // Returns bool()
                        std::is_invocable_r_v<void, F>;               // Returns void()

class TOAST_API Listener {
  struct Handle {
    std::type_index type;
    std::string name;
    std::any iterator;
  };
 
  struct {
    std::vector<Handle> callbacks;
    std::atomic<bool>* enabled;
  } m;
 
public:
  Listener();
  Listener(bool state);
  ~Listener();

  template<typename TEvent>
  void unsubscribe(std::string_view name) noexcept;

  template<typename TEvent, EventCallback<TEvent&> F>
  void subscribe(std::string name, F&& callback, char priority = 0) noexcept;

  template<typename TEvent, EventCallback<TEvent&> F>
  void subscribe(F&& callback, char priority = 0) noexcept;

  void enabled(bool state);

  [[nodiscard]]
  auto enabled() const -> bool;
};
}
 
#include "listener.inl"