Event.hpp

#pragma once
 
#include "Delegate.hpp"
 
#include <mutex>
#include <vector>
 
namespace CP_SDK::Utils {
 
    template <class t_FnType> class EventImpl;
 
 
    template <class t_Ret, class... t_Args> class EventImpl<t_Ret(t_Args...)>
    {
        EventImpl(const EventImpl&) = delete;
        EventImpl(EventImpl&&) = delete;
 
        public:
            EventImpl()
            {
 
            }
 
            EventImpl& operator+=(const Delegate<void(t_Args...)> & p_Delegate)
            {
                std::lock_guard l_Guard(m_Mutex);
 
                auto l_It = std::find_if(m_Delegates.begin(), m_Delegates.end(), [&p_Delegate](const Delegate<void(t_Args...)> & p_Item) -> bool {
                    return p_Item.EqualTo(&p_Delegate);
                });
 
                if (l_It == m_Delegates.end())
                    m_Delegates.push_back(p_Delegate);
 
                return *this;
            }
            EventImpl& operator-=(const Delegate<void(t_Args...)> &  p_Delegate)
            {
                std::lock_guard l_Guard(m_Mutex);
 
                auto l_It = std::find_if(m_Delegates.begin(), m_Delegates.end(), [&p_Delegate](const Delegate<void(t_Args...)> & p_Item) -> bool {
                    return p_Item.EqualTo(&p_Delegate);
                });
 
                if (l_It != m_Delegates.end())
                    m_Delegates.erase(l_It);
 
                return *this;
            }
 
            void Clear()
            {
                m_Mutex.lock();
                m_Delegates.clear();
                m_Mutex.unlock();
            }
 
            void operator()(t_Args... p_Args)
            {
                Invoke(std::forward<t_Args>(p_Args)...);
            }
            void Invoke(t_Args... p_Args)
            {
                m_Mutex.lock();
                std::vector<Delegate<void(t_Args...)>> l_Copy = m_Delegates;
                m_Mutex.unlock();
 
                for (const auto & l_Delegate : l_Copy)
                    l_Delegate.Invoke(std::forward<t_Args>(p_Args)...);
            }
 
        private:
            std::mutex                                 m_Mutex;        
            std::vector<Delegate<void(t_Args...)>>     m_Delegates;    
 
    };
 
 
    template <class... t_Args>
    class Event : public EventImpl<void(t_Args...)>
    {
        using EventImpl<void(t_Args...)>::EventImpl;
    };
 
}