event.h

Go to the documentation of this file.

 
#ifndef MINESERVER_EVENT_HPP
#define MINESERVER_EVENT_HPP
 
#include <functional>
#include <type_traits>
#include <plugins/luaheaders.h>
 
template<class T>
class IEvent
{
public:
    static void loadLua(lua_State *state);
};
 
#ifndef DOXYGEN_IGNORE_THIS
namespace logger
{
    void error(const char *format, ...);
}
#endif // DOXYGEN_IGNORE_THIS
 
template <typename T>
constexpr std::string_view type_name()
{
    std::string_view name, prefix, suffix;
#ifdef __clang__
    name = __PRETTY_FUNCTION__;
  prefix = "auto type_name() [T = ";
  suffix = "]";
#elif defined(__GNUC__)
    name = __PRETTY_FUNCTION__;
    prefix = "constexpr auto type_name() [with T = ";
    suffix = "]";
#elif defined(_MSC_VER)
    name = __FUNCSIG__;
  prefix = "auto __cdecl type_name<";
  suffix = ">(void)";
#endif
    name.remove_prefix(prefix.size());
    name.remove_suffix(suffix.size());
    return name;
}
 
template <class T>
class EventHandler
{
public:
    typedef std::function<void(T &)> callbackType;
    typedef int subId;
 
private:
    struct subscription
    {
        callbackType callback;
        subId id;
    };
 
    std::vector<subscription> subs;
    subId nextId = 0;
    const std::type_info *typeInfo;
 
    subId getNextId()
    {
        return ++nextId;
    }
 
public:
    EventHandler() : subs()
    {
        static_assert(std::is_base_of_v<IEvent<T>, T>, "Class doesn't derive from IEvent");
        typeInfo = &typeid(T);
    }
 
    ~EventHandler() = default;
 
    void fire(T &event)
    {
        for (auto &sub : subs)
        {
            try {
                sub.callback(event);
            }
            catch (const std::exception &e)
            {
                logger::error("Could not launch event %s", std::string(type_name<T>()).c_str());
            }
        }
    }
 
    subId subscribe(const callbackType &func)
    {
        subscription s;
        s.callback = static_cast<callbackType>(func);
        s.id = getNextId();
        subs.push_back(s);
        return s.id;
    }
 
    subId subscribe(callbackType &&func)
    {
        subscription s;
        s.callback = std::move(func);
        s.id = getNextId();
        subs.push_back(s);
        return s.id;
    }
 
    void unsubscribe(subId id)
    {
        subs.erase(
            std::remove_if(
                subs.begin(),
                subs.end(),
                [id](subscription el) -> bool
                {
                    return el.id == id;
                }),
            subs.end());
    }
 
    const std::type_info *getTypeInfo() const { return typeInfo; }
};
 
class EventsManager
{
private:
    std::vector<EventHandler<void *> *> handlers;
    static EventsManager *INSTANCE;
 
    template <class T>
    EventHandler<T> *getOrNull()
    {
        auto loc = std::find_if(handlers.begin(), handlers.end(), [](const EventHandler<void *> *entry)
                                { return *entry->getTypeInfo() == typeid(T); });
 
        if (loc == handlers.end())
            return nullptr;
 
        return reinterpret_cast<EventHandler<T> *>(*loc);
    }
 
    template <class T>
    EventHandler<T> *getOrCreateHandler()
    {
        auto handler = getOrNull<T>();
 
        if (!handler)
        {
            handler = new EventHandler<T>();
            handlers.push_back(reinterpret_cast<EventHandler<void *> *>(handler));
        }
 
        return handler;
    }
 
public:
    EventsManager();
 
    ~EventsManager()
    {
        auto loc = handlers.begin();
        while (loc != handlers.end())
        {
            delete *loc;
            loc = handlers.erase(loc);
        }
    }
 
    template <class T>
    typename EventHandler<T>::subId subscribe(const typename EventHandler<T>::callbackType &callback)
    {
        static_assert(std::is_base_of_v<IEvent<T>, T>, "Class doesn't derive from IEvent");
        EventHandler<T> *handler = getOrCreateHandler<T>();
        return handler->subscribe(callback);
    }
 
    template <class T>
    typename EventHandler<T>::subId subscribe(typename EventHandler<T>::callbackType &&callback)
    {
        static_assert(std::is_base_of_v<IEvent<T>, T>, "Class doesn't derive from IEvent");
        EventHandler<T> *handler = getOrCreateHandler<T>();
        return handler->subscribe(std::move(callback));
    }
 
    template <class T>
    void unsubscribe(typename EventHandler<T>::subId subId)
    {
        static_assert(std::is_base_of_v<IEvent<T>, T>, "Class doesn't derive from IEvent");
        EventHandler<T> *handler = getOrCreateHandler<T>();
        return handler->unsubscribe(subId);
    }
 
    template <class T>
    void fire(T &event)
    {
        static_assert(std::is_base_of_v<IEvent<T>, T>, "Class doesn't derive from IEvent");
        EventHandler<T> *handler = getOrNull<T>();
 
        if (handler)
        {
            handler->fire(event);
        }
    }
 
    static EventsManager *inst();
};
 
template<class T>
void IEvent<T>::loadLua(lua_State *state) {
    auto baseName = std::string(type_name<T>());
    std::string cleanedEvent = baseName.substr(0, baseName.length() - std::string("Event").length());
    static_assert(std::is_base_of_v<IEvent, T>, "Class doesn't derive from IEvent");
    luabridge::getGlobalNamespace(state)
            .beginNamespace("event")
            .addFunction(("on"+cleanedEvent).c_str(), [](const luabridge::LuaRef& ref) {
                if(!ref.isFunction())
                    return;
 
                EventsManager::inst()->subscribe<T>(const_cast<luabridge::LuaRef&>(ref));
            })
            .template beginClass<T>(cleanedEvent.c_str())
            .endClass()
            .endNamespace();
}
 
#endif // MINESERVER_EVENT_HPP