EventManager.h

Go to the documentation of this file.

// Copyright (c) 2025 Dave R. Smith.
// Malena Framework — Licensed under PolyForm Noncommercial 1.0.0; commercial use requires a paid license. See LICENSE.
 
//
// EventManager.h
//
 
#ifndef MALENA_EVENTSMANAGER_H
#define MALENA_EVENTSMANAGER_H
 
#include <Malena/Core/malena_export.h>
#include <map>
#include <string>
#include <vector>
#include <Malena/Engine/Events/Callback.h>
#include <Malena/Core/DeferredOperationsManager.h>
#include <Malena/Utilities/EnumKey.h>
#include <SFML/Window/Event.hpp>
#include <optional>
 
namespace ml
{
    class Fireable;
    class EventReceiver;
    class Core;
    class Unsubscribable;

    class MALENA_API EventManager : public DeferredOperationsManager<EventManager>
    {
        struct Subscriber
        {
            EventReceiver* receiver;  
            Core*          core;      
        };
 
        inline static std::map<
            std::string,
            std::vector<Subscriber>
        > _subscribers;
 
    public:
        template<typename EnumType>
        static void subscribe(EnumType eventEnum, EventReceiver* component, Core* core = nullptr)
        {
            // `core` may be supplied by callers that already KNOW the Core
            // identity — notably ComponentCore, which subscribes from inside its
            // own constructor. Resolving it there by dynamic_cast would be a
            // cast on a partially-constructed object: undefined, tolerated by
            // Clang, and a hard RTTI failure on MSVC (0xC0000409 at startup).
            doSubscribe(EnumKey::get(eventEnum), component, core);
        }

        template<typename EnumType>
        static void unsubscribe(EnumType eventEnum, Core* core)
        {
            deferOrExecute([key = EnumKey::get(eventEnum), core]()
            {
                doUnsubscribe(key, core);
            });
        }

        static void unsubscribeAll(Core* core);

        static void clear();

        static bool hasReceiver(EventReceiver* receiver);

        template<typename EnumType>
        static void fire(EnumType eventEnum,
                         Fireable* dispatcher,
                         const std::optional<sf::Event>& event,
                         SystemCallback resolve = nullptr,
                         SystemCallback reject  = nullptr)
        {
            doFire(EnumKey::get(eventEnum), dispatcher, event, resolve, reject);
        }
 
        friend class AppManager;
        friend class Fireable;
        friend class Core;
        friend class Unsubscribable;
 
    private:
        static void unsubscribe(const std::string& key, Core* core)
        {
            deferOrExecute([key, core]() { doUnsubscribe(key, core); });
        }
 
 
 
        static void doSubscribe(const std::string& key, EventReceiver* component, Core* core = nullptr);
        static void doFire(const std::string& key,
                           Fireable* dispatcher,
                           const std::optional<sf::Event>& event,
                           SystemCallback resolve,
                           SystemCallback reject);
        static void doUnsubscribe(const std::string& key, Core* core);
        static void doUnsubscribeAll(Core* core);
 
    public:
        static void forceUnsubscribeAll(Core* core);
    };
 
} // namespace ml
 
#endif // MALENA_EVENTSMANAGER_H