@abbq np tak:
namespace application {
template <typename T, typename U>
class event_registry {
public:
using event_handler = std::function<bool(const U&)>;
void register_handler(const T& event_type, const event_handler& handler);
void unregister_handler(const T& event_type);
bool call_handler(const T& event_type, const U& window_event) const;
private:
using registry_handler = std::unordered_map<T, event_handler>;
registry_handler registry;
};
template <typename T, typename U>
inline void event_registry<T, U>::register_handler(const T& event_type, const event_handler& handler) {
registry[event_type] = handler;
}
template <typename T, typename U>
inline void event_registry<T, U>::unregister_handler(const T& event_type) {
auto handler = registry.find(event_type);
if (handler != std::end(registry))
registry.erase(handler);
}
template<typename T, typename U>
inline bool event_registry<T, U>::call_handler(const T& event_type, const U& window_event) const {
auto handler = registry.find(event_type);
if (handler == std::end(registry))
return false;
return handler->second(window_event);
}
template <typename T, typename U>
class event_registrar {
public:
virtual ~event_registrar() = default;
virtual bool handle_event(const T& event_type, const U& event) const;
protected:
event_registry<T, U> event_handler_registry;
};
template <typename T, typename U>
inline bool event_registrar<T, U>::handle_event(const T& event_type, const U& event) const {
return event_handler_registry.call_handler(event_type, event);
}
class sfml_window;
class sfml_event_registrar : public event_registrar<sf::Event::EventType, sf::Event> {
public:
sfml_event_registrar(const std::shared_ptr<sfml_window>& window_handler);
private:
std::shared_ptr<sfml_window> window_handler;
};
sfml_event_registrar::sfml_event_registrar(const std::shared_ptr<sfml_window>& _window_handler)
: window_handler(_window_handler) {
event_handler_registry.register_handler(sf::Event::Closed, [this](const sf::Event& event) {
window_handler->close();
return true;
});
}
}