Event.h

#pragma once
 
#include "Delegate.h"
#include "Internal.h"
#include <cassert>
#include <cstddef>
#include <limits>
 
namespace sw
{
    // 向前声明
    template <typename>
    class Event;
 
    /*================================================================================*/
 
    template <typename TOwner, typename TDelegate>
    class MemberEventInitializer
    {
        template <typename>
        friend class Event;
 
    private:
        TOwner *_owner;
 
        TDelegate &(*_accessor)(TOwner *);
 
    public:
        explicit MemberEventInitializer(TOwner *owner)
            : _owner(owner), _accessor(nullptr)
        {
        }
 
        MemberEventInitializer &Delegate(TDelegate &(*accessor)(TOwner *))
        {
            _accessor = accessor;
            return *this;
        }
 
        template <TDelegate (TOwner::*accessor)()>
        MemberEventInitializer &Delegate()
        {
            return Delegate([](TOwner *owner) -> TDelegate & {
                return (owner->*accessor)();
            });
        }
 
        template <TDelegate (TOwner::*accessor)() const>
        MemberEventInitializer &Delegate()
        {
            return Delegate([](TOwner *owner) -> TDelegate & {
                return (owner->*accessor)();
            });
        }
 
        template <TDelegate TOwner::*field>
        MemberEventInitializer &Delegate()
        {
            return Delegate([](TOwner *owner) -> TDelegate & {
                return owner->*field;
            });
        }
    };
 
    template <typename TDelegate>
    class StaticEventInitializer
    {
        template <typename>
        friend class Event;
 
    private:
        TDelegate &(*_accessor)();
 
    public:
        StaticEventInitializer()
            : _accessor(nullptr)
        {
        }
 
        StaticEventInitializer &Delegate(TDelegate &(*accessor)())
        {
            _accessor = accessor;
            return *this;
        }
    };
 
    /*================================================================================*/
 
    template <typename TRet, typename... Args>
    class Event<Delegate<TRet(Args...)>> final
    {
    public:
        using TDelegate = Delegate<TRet(Args...)>;
 
        using TEvent = Event<TDelegate>;
 
    public:
        template <typename TOwner>
        explicit Event(const MemberEventInitializer<TOwner, TDelegate> &initializer)
        {
            assert(initializer._owner != nullptr);
            assert(initializer._accessor != nullptr);
 
            SetOwner(initializer._owner);
            _accessor = reinterpret_cast<void *>(initializer._accessor);
 
            _extractor = [](void *owner, void *accessor) -> TDelegate & {
                return reinterpret_cast<TDelegate &(*)(TOwner *)>(accessor)(reinterpret_cast<TOwner *>(owner));
            };
        }
 
        explicit Event(const StaticEventInitializer<TDelegate> &initializer)
        {
            assert(initializer._accessor != nullptr);
 
            SetOwner(nullptr);
            _accessor = reinterpret_cast<void *>(initializer._accessor);
 
            _extractor = [](void * /*owner*/, void *accessor) -> TDelegate & {
                return reinterpret_cast<TDelegate &(*)()>(accessor)();
            };
        }
 
        template <typename T>
        auto operator+=(T &&handler) const
            -> typename std::enable_if<_DelegateCanAddSubtract<TDelegate, T>::value>::type
        {
            this->GetDelegate() += std::forward<T>(handler);
        }
 
        template <typename T>
        auto operator-=(T &&handler) const
            -> typename std::enable_if<_DelegateCanAddSubtract<TDelegate, T>::value>::type
        {
            this->GetDelegate() -= std::forward<T>(handler);
        }
 
    public:
        template <typename TOwner>
        static MemberEventInitializer<TOwner, TDelegate> Init(TOwner *owner)
        {
            return MemberEventInitializer<TOwner, TDelegate>(owner);
        }
 
        static StaticEventInitializer<TDelegate> Init()
        {
            return StaticEventInitializer<TDelegate>();
        }
 
    private:
        static constexpr std::ptrdiff_t _STATICOFFSET =
            (std::numeric_limits<std::ptrdiff_t>::max)();
 
        std::ptrdiff_t _offset;
 
        void *_accessor;
 
        TDelegate &(*_extractor)(void *owner, void *accessor);
 
        bool IsStatic() const noexcept
        {
            return _offset == _STATICOFFSET;
        }
 
        void SetOwner(void *owner) noexcept
        {
            if (owner == nullptr) {
                _offset = _STATICOFFSET;
            } else {
                _offset = reinterpret_cast<uint8_t *>(owner) - reinterpret_cast<uint8_t *>(this);
            }
        }
 
        void *GetOwner() const noexcept
        {
            if (IsStatic()) {
                return nullptr;
            } else {
                return const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(this)) + _offset;
            }
        }
 
        TDelegate &GetDelegate() const
        {
            return _extractor(GetOwner(), _accessor);
        }
    };
 
    /*================================================================================*/
 
    struct EventArgs {};
 
    template <typename TSender, typename TEventArgs = EventArgs>
    using EventHandler = Delegate<void(TSender &, TEventArgs &)>;
}