event.h

Go to the documentation of this file.

 
#ifndef EVENT_H
#define EVENT_H
 
#include <algorithm>
#include <functional>
#include <mutex>
#include <type_traits>
#include <vector>
#include "eventargs.h"
 
namespace Nickvision::Events
{
    template<typename T>
    concept DerivedEventArgs = std::is_base_of_v<EventArgs, T>;

    enum class HandlerId : size_t {};

    template <DerivedEventArgs T>
    class Event
    {
    public:
        Event() = default;
        Event(const Event& e)
        { 
            std::lock_guard<std::mutex> lock{ e.m_mutex };
            m_handlers = e.m_handlers;
        }

        Event(Event&& e) noexcept
        {
            std::lock_guard<std::mutex> lock{ e.m_mutex };
            m_handlers = std::move(e.m_handlers);
        }

        size_t count() const
        {
            std::lock_guard<std::mutex> lock{ m_mutex };
            return m_handlers.size();
        }

        HandlerId subscribe(const std::function<void(const T&)>& handler)
        {
            std::lock_guard<std::mutex> lock{ m_mutex };
            m_handlers.push_back(handler);
            return HandlerId{ m_handlers.size() - 1 };
        }

        void unsubscribe(HandlerId id)
        {
            std::lock_guard<std::mutex> lock{ m_mutex };
            if (static_cast<size_t>(id) < 0 || static_cast<size_t>(id) >= m_handlers.size())
            {
                return;
            }
            m_handlers.erase(m_handlers.begin() + static_cast<size_t>(id));
        }

        void invoke(const T& param) const
        {
            std::lock_guard<std::mutex> lock{ m_mutex };
            for (const std::function<void(const T&)>& handler : m_handlers)
            {
                handler(param);
            }
        }

        HandlerId operator+=(const std::function<void(const T&)>& handler)
        {
            return subscribe(handler);
        }

        void operator-=(HandlerId id)
        {
            unsubscribe(id);
        }

        void operator()(const T& param)
        {
            invoke(param);
        }

        Event& operator=(const Event& e)
        {
            if (this != &e)
            {
                std::lock_guard<std::mutex> lock{ m_mutex };
                std::lock_guard<std::mutex> lock2{ e.m_mutex };
                m_handlers = e.m_handlers;
            }
            return *this;
        }

        Event& operator=(Event&& e) noexcept
        {
            if (this != &e)
            {
                std::lock_guard<std::mutex> lock{ m_mutex };
                std::lock_guard<std::mutex> lock2{ e.m_mutex };
                m_handlers = std::move(e.m_handlers);
            }
            return *this;
        }

        operator bool() const
        {
            return count() > 0;
        }
 
    private:
        mutable std::mutex m_mutex;
        std::vector<std::function<void(const T&)>> m_handlers;
    };
}
 
#endif //EVENT_H