EventManager.h

Go to the documentation of this file.

//
// EventsManager.h
//
 
#ifndef _EVENTSMANAGER_H
#define _EVENTSMANAGER_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"
 
namespace ml
{
    class Fireable;
    class EventReceiver;
    class Core;
    class Unsubscribable;

    class 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)
        {
            doSubscribe(EnumKey::get(eventEnum), component);
        }

        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();

        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);
        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 // _EVENTSMANAGER_H