Delegate.hpp

#pragma once
 
#include "Internals/DelegateInvokerI.hpp"
#include "Internals/DelegateInvokerL.hpp"
#include "Internals/DelegateInvokerS.hpp"
#include "Internals/LambdaSignatureHelper.hpp"
 
namespace CP_SDK::Utils {
 
    template <class t_FnType> class DelegateImpl;
 
 
    template<class t_Ret, class... t_Args>
    class DelegateImpl<t_Ret(t_Args...)>
    {
        public:
            DelegateImpl()
            {
                m_Invoker = nullptr;
            }
            DelegateImpl(t_Ret(*p_Handler)(t_Args...))
            {
                m_Invoker = std::make_shared<Internals::DelegateInvokerS<t_Ret, t_Args...>>(p_Handler);
            }
            template<class t_Class> DelegateImpl(t_Class * p_Owner, t_Ret(t_Class::* p_Handler)(t_Args...))
            {
                m_Invoker = std::make_shared<Internals::DelegateInvokerI<t_Class, t_Ret, t_Args...>>(p_Owner, p_Handler);
            }
            template<class t_Lambda> DelegateImpl(t_Ret(*p_Null)(t_Args...), const t_Lambda & p_Lambda)
            {
                m_Invoker = std::make_shared<Internals::DelegateInvokerL<t_Lambda, t_Ret, t_Args...>>(p_Lambda);
            }
            DelegateImpl(const DelegateImpl<t_Ret(t_Args...)> & p_Other)
            {
                m_Invoker = p_Other.m_Invoker;
            }
            DelegateImpl(DelegateImpl<t_Ret(t_Args...)> && p_Other)
            {
                m_Invoker = p_Other.m_Invoker;
                p_Other.m_Invoker = nullptr;
            }
            virtual ~DelegateImpl()
            {
                m_Invoker = nullptr;
            }
 
        public:
            DelegateImpl& operator=(const DelegateImpl& p_Other)
            {
                m_Invoker = p_Other.m_Invoker;
                return *this;
            }
 
        public:
            bool IsValid() const
            {
                return m_Invoker ? m_Invoker->IsValid() : false;
            }
 
        public:
            bool EqualTo(const DelegateImpl<t_Ret(t_Args...)>* p_Other) const
            {
                return m_Invoker && p_Other && m_Invoker->EqualTo(p_Other->m_Invoker.get());
            }
            t_Ret operator()(t_Args... p_Args) const
            {
                return Invoke(std::forward<t_Args>(p_Args)...);
            }
            t_Ret Invoke(t_Args... p_Args) const
            {
                if (!IsValid())
                {
                    if constexpr (std::is_reference<t_Ret>::value)
                    {
                        static typename std::remove_reference<t_Ret>::type s_Defaultt_Ret;
                        return s_Defaultt_Ret;
                    }
                    else
                        return t_Ret();
                }
 
                return m_Invoker->Invoke(std::forward<t_Args>(p_Args)...);
            }
 
        private:
            std::shared_ptr<Internals::IDelegateInvoker<t_Ret, t_Args...>> m_Invoker;
 
    };
 
 
    template <class t_FnType>
    class Delegate : public DelegateImpl<t_FnType>
    {
        using DelegateImpl<t_FnType>::DelegateImpl;
 
        public:
            template<class t_Lambda, class t_Sig = typename Internals::LambdaSignatureHelper<decltype(&t_Lambda::operator())>::Signature>
            Delegate(const t_Lambda & p_Lambda)
                : DelegateImpl<t_Sig>((t_Sig*)nullptr, p_Lambda)
            {
 
            }
            virtual ~Delegate()
            {
 
            }
 
    };
 
 
    template <class... t_Args>
    using Action = Delegate<void(t_Args...)>;
 
    template <class... t_Args>
    using CActionRef = const Delegate<void(t_Args...)>&;
 
 
    template <class t_Ret, class... t_Args>
    using Func = Delegate<t_Ret(t_Args...)>;
 
    template <class t_Ret, class... t_Args>
    using CFuncRef = const Delegate<t_Ret(t_Args...)>&;
 
}