Delegate.h

#pragma once
 
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <memory>
#include <stdexcept>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <vector>
 
namespace sw
{
    // ICallable接口声明
    template <typename>
    struct ICallable;
 
    // Delegate类声明
    template <typename>
    class Delegate;
 
    /*================================================================================*/
 
    template <typename TRet, typename... Args>
    struct ICallable<TRet(Args...)> {
        virtual ~ICallable() = default;
 
        virtual TRet Invoke(Args... args) const = 0;
 
        virtual ICallable *Clone() const = 0;
 
        virtual std::type_index GetType() const = 0;
 
        virtual bool Equals(const ICallable &other) const = 0;
    };
 
    /*================================================================================*/
 
    template <typename T>
    class CallableList
    {
    public:
        using TCallable = ICallable<T>;
 
        using TSinglePtr = std::unique_ptr<TCallable>;
 
        using TSharedList = std::vector<std::shared_ptr<TCallable>>;
 
    private:
        mutable union {
            alignas(TSinglePtr) uint8_t _single[sizeof(TSinglePtr)];
            alignas(TSharedList) uint8_t _list[sizeof(TSharedList)];
        } _data = {};
 
        enum : uint8_t {
            STATE_NONE,   
            STATE_SINGLE, 
            STATE_LIST,   
        } _state = STATE_NONE;
 
    public:
        CallableList()
        {
        }
 
        CallableList(const CallableList &other)
        {
            *this = other;
        }
 
        CallableList(CallableList &&other) noexcept
        {
            *this = std::move(other);
        }
 
        CallableList &operator=(const CallableList &other)
        {
            if (this == &other) {
                return *this;
            }
 
            switch (other._state) {
                case STATE_NONE: {
                    _Reset();
                    break;
                }
                case STATE_SINGLE: {
                    std::unique_ptr<TCallable> cloned(other._GetSingle()->Clone());
                    _Reset(STATE_SINGLE);
                    _GetSingle() = std::move(cloned);
                    break;
                }
                case STATE_LIST: {
                    TSharedList copied = other._GetList();
                    _Reset(STATE_LIST);
                    _GetList() = std::move(copied);
                    break;
                }
            }
            return *this;
        }
 
        CallableList &operator=(CallableList &&other) noexcept
        {
            if (this == &other) {
                return *this;
            }
 
            _Reset(other._state);
 
            switch (other._state) {
                case STATE_NONE: {
                    break;
                }
                case STATE_SINGLE: {
                    _GetSingle() = std::move(other._GetSingle());
                    other._Reset();
                    break;
                }
                case STATE_LIST: {
                    _GetList() = std::move(other._GetList());
                    other._Reset();
                    break;
                }
            }
            return *this;
        }
 
        ~CallableList()
        {
            _Reset();
        }
 
        size_t Count() const noexcept
        {
            switch (_state) {
                case STATE_SINGLE: {
                    return 1;
                }
                case STATE_LIST: {
                    return _GetList().size();
                }
                default: {
                    return 0;
                }
            }
        }
 
        bool IsEmpty() const noexcept
        {
            return _state == STATE_NONE;
        }
 
        void Clear() noexcept
        {
            _Reset();
        }
 
        void Add(TCallable *callable)
        {
            TSinglePtr owned(callable);
 
            if (owned == nullptr) {
                return;
            }
 
            switch (_state) {
                case STATE_NONE: {
                    _Reset(STATE_SINGLE);
                    _GetSingle() = std::move(owned);
                    break;
                }
                case STATE_SINGLE: {
                    TSharedList list;
                    list.reserve(2);
                    std::shared_ptr<TCallable> incoming(std::move(owned));
                    std::shared_ptr<TCallable> current(std::move(_GetSingle()));
                    list.emplace_back(std::move(current));
                    list.emplace_back(std::move(incoming));
                    _Reset(STATE_LIST);
                    _GetList() = std::move(list);
                    break;
                }
                case STATE_LIST: {
                    std::shared_ptr<TCallable> sp(std::move(owned));
                    _GetList().emplace_back(std::move(sp));
                    break;
                }
            }
        }
 
        bool RemoveAt(size_t index) noexcept
        {
            switch (_state) {
                case STATE_SINGLE: {
                    if (index != 0) {
                        return false;
                    } else {
                        _Reset();
                        return true;
                    }
                }
                case STATE_LIST: {
                    auto &list = _GetList();
                    if (index >= list.size()) {
                        return false;
                    }
                    list.erase(list.begin() + index);
                    if (list.empty()) {
                        _Reset();
                    }
                    // 注：LIST 仅剩 1 元素时不降级回 SINGLE。shared_ptr 无法转移给
                    // unique_ptr，强行 Clone 反而带来额外开销，保留 LIST 单元素状态
                    // 在功能与性能上都可接受。
                    return true;
                }
                default: {
                    return false;
                }
            }
        }
 
        TCallable *GetAt(size_t index) const noexcept
        {
            switch (_state) {
                case STATE_SINGLE: {
                    return index == 0 ? _GetSingle().get() : nullptr;
                }
                case STATE_LIST: {
                    auto &list = _GetList();
                    return (index < list.size()) ? list[index].get() : nullptr;
                }
                default: {
                    return nullptr;
                }
            }
        }
 
        TCallable *operator[](size_t index) const noexcept
        {
            return GetAt(index);
        }
 
    private:
        constexpr TSinglePtr &_GetSingle() const noexcept
        {
            return *reinterpret_cast<TSinglePtr *>(_data._single);
        }
 
        constexpr TSharedList &_GetList() const noexcept
        {
            return *reinterpret_cast<TSharedList *>(_data._list);
        }
 
        void _Reset() noexcept
        {
            switch (_state) {
                case STATE_NONE: {
                    break;
                }
                case STATE_SINGLE: {
                    _GetSingle().~TSinglePtr();
                    _state = STATE_NONE;
                    break;
                }
                case STATE_LIST: {
                    _GetList().~TSharedList();
                    _state = STATE_NONE;
                    break;
                }
            }
        }
 
        void _Reset(uint8_t state) noexcept
        {
            _Reset();
 
            switch (state) {
                case STATE_SINGLE: {
                    new (_data._single) TSinglePtr();
                    _state = STATE_SINGLE;
                    break;
                }
                case STATE_LIST: {
                    new (_data._list) TSharedList();
                    _state = STATE_LIST;
                    break;
                }
            }
        }
    };
 
    /*================================================================================*/
 
    template <typename TRet, typename... Args>
    class Delegate<TRet(Args...)> final : public ICallable<TRet(Args...)>
    {
    private:
        using _ICallable = ICallable<TRet(Args...)>;
 
        template <typename T, typename = void>
        struct _IsEqualityComparable : std::false_type {
        };
 
        template <typename T>
        struct _IsEqualityComparable<
            T, decltype(void(std::declval<T>() == std::declval<T>()))> : std::true_type {
        };
 
        template <typename T, typename = void>
        struct _IsMemcmpSafe : std::false_type {
        };
 
        template <typename T>
        struct _IsMemcmpSafe<
            T,
            typename std::enable_if</*std::is_trivial<T>::value &&*/ std::is_standard_layout<T>::value, void>::type> : std::true_type {
        };
 
        template <typename T>
        class _CallableWrapperImpl final : public _ICallable
        {
            alignas(T) mutable uint8_t _storage[sizeof(T)];
 
        public:
            _CallableWrapperImpl(const T &value)
            {
                memset(_storage, 0, sizeof(_storage));
                new (_storage) T(value);
            }
            _CallableWrapperImpl(T &&value)
            {
                memset(_storage, 0, sizeof(_storage));
                new (_storage) T(std::move(value));
            }
            virtual ~_CallableWrapperImpl()
            {
                GetValue().~T();
                // memset(_storage, 0, sizeof(_storage));
            }
            T &GetValue() const noexcept
            {
                return *reinterpret_cast<T *>(_storage);
            }
            TRet Invoke(Args... args) const override
            {
                return GetValue()(std::forward<Args>(args)...);
            }
            _ICallable *Clone() const override
            {
                return new _CallableWrapperImpl(GetValue());
            }
            virtual std::type_index GetType() const override
            {
                return typeid(T);
            }
            bool Equals(const _ICallable &other) const override
            {
                return EqualsImpl(other);
            }
            template <typename U = T>
            auto EqualsImpl(const _ICallable &other) const
                -> typename std::enable_if<_IsEqualityComparable<U>::value, bool>::type
            {
                if (this == &other) {
                    return true;
                }
                if (GetType() != other.GetType()) {
                    return false;
                }
                const auto &otherWrapper = static_cast<const _CallableWrapperImpl &>(other);
                return GetValue() == otherWrapper.GetValue();
            }
            template <typename U = T>
            auto EqualsImpl(const _ICallable &other) const
                -> typename std::enable_if<!_IsEqualityComparable<U>::value && _IsMemcmpSafe<U>::value, bool>::type
            {
                if (this == &other) {
                    return true;
                }
                if (GetType() != other.GetType()) {
                    return false;
                }
                const auto &otherWrapper = static_cast<const _CallableWrapperImpl &>(other);
                return memcmp(_storage, otherWrapper._storage, sizeof(_storage)) == 0;
            }
            template <typename U = T>
            auto EqualsImpl(const _ICallable &other) const
                -> typename std::enable_if<!_IsEqualityComparable<U>::value && !_IsMemcmpSafe<U>::value, bool>::type
            {
                return this == &other;
            }
 
        public:
            // 禁用拷贝/移动：默认实现会按字节拷贝 _storage，不会调用 T 的构造函数，
            // 对非平凡可拷贝类型会破坏不变式。需要克隆请走 Clone()。
            _CallableWrapperImpl(const _CallableWrapperImpl &)            = delete;
            _CallableWrapperImpl(_CallableWrapperImpl &&)                 = delete;
            _CallableWrapperImpl &operator=(const _CallableWrapperImpl &) = delete;
            _CallableWrapperImpl &operator=(_CallableWrapperImpl &&)      = delete;
        };
 
        template <typename T>
        using _CallableWrapper = _CallableWrapperImpl<typename std::decay<T>::type>;
 
        template <typename T>
        class _MemberFuncWrapper final : public _ICallable
        {
            T *obj;
            TRet (T::*func)(Args...);
 
        public:
            _MemberFuncWrapper(T &obj, TRet (T::*func)(Args...))
                : obj(&obj), func(func)
            {
            }
            TRet Invoke(Args... args) const override
            {
                return (obj->*func)(std::forward<Args>(args)...);
            }
            _ICallable *Clone() const override
            {
                return new _MemberFuncWrapper(*obj, func);
            }
            virtual std::type_index GetType() const override
            {
                return typeid(func);
            }
            bool Equals(const _ICallable &other) const override
            {
                if (this == &other) {
                    return true;
                }
                if (GetType() != other.GetType()) {
                    return false;
                }
                const auto &otherWrapper = static_cast<const _MemberFuncWrapper &>(other);
                return obj == otherWrapper.obj && func == otherWrapper.func;
            }
 
        public:
            // 禁用拷贝/移动：与 _CallableWrapperImpl 保持一致，需要克隆请走 Clone()。
            _MemberFuncWrapper(const _MemberFuncWrapper &)            = delete;
            _MemberFuncWrapper(_MemberFuncWrapper &&)                 = delete;
            _MemberFuncWrapper &operator=(const _MemberFuncWrapper &) = delete;
            _MemberFuncWrapper &operator=(_MemberFuncWrapper &&)      = delete;
        };
 
        template <typename T>
        class _ConstMemberFuncWrapper final : public _ICallable
        {
            const T *obj;
            TRet (T::*func)(Args...) const;
 
        public:
            _ConstMemberFuncWrapper(const T &obj, TRet (T::*func)(Args...) const)
                : obj(&obj), func(func)
            {
            }
            TRet Invoke(Args... args) const override
            {
                return (obj->*func)(std::forward<Args>(args)...);
            }
            _ICallable *Clone() const override
            {
                return new _ConstMemberFuncWrapper(*obj, func);
            }
            virtual std::type_index GetType() const override
            {
                return typeid(func);
            }
            bool Equals(const _ICallable &other) const override
            {
                if (this == &other) {
                    return true;
                }
                if (GetType() != other.GetType()) {
                    return false;
                }
                const auto &otherWrapper = static_cast<const _ConstMemberFuncWrapper &>(other);
                return obj == otherWrapper.obj && func == otherWrapper.func;
            }
 
        public:
            // 禁用拷贝/移动：与 _CallableWrapperImpl 保持一致，需要克隆请走 Clone()。
            _ConstMemberFuncWrapper(const _ConstMemberFuncWrapper &)            = delete;
            _ConstMemberFuncWrapper(_ConstMemberFuncWrapper &&)                 = delete;
            _ConstMemberFuncWrapper &operator=(const _ConstMemberFuncWrapper &) = delete;
            _ConstMemberFuncWrapper &operator=(_ConstMemberFuncWrapper &&)      = delete;
        };
 
    private:
        CallableList<TRet(Args...)> _data;
 
    public:
        Delegate(std::nullptr_t = nullptr)
        {
        }
 
        Delegate(const ICallable<TRet(Args...)> &callable)
        {
            Add(callable);
        }
 
        Delegate(TRet (*func)(Args...))
        {
            Add(func);
        }
 
        template <typename T, typename std::enable_if<!std::is_base_of<_ICallable, T>::value, int>::type = 0>
        Delegate(const T &callable)
        {
            Add(callable);
        }
 
        template <typename T>
        Delegate(T &obj, TRet (T::*func)(Args...))
        {
            Add(obj, func);
        }
 
        template <typename T>
        Delegate(const T &obj, TRet (T::*func)(Args...) const)
        {
            Add(obj, func);
        }
 
        Delegate(const Delegate &other)
        {
            for (size_t i = 0; i < other._data.Count(); ++i) {
                _data.Add(other._data[i]->Clone());
            }
        }
 
        Delegate(Delegate &&other) noexcept
            : _data(std::move(other._data))
        {
        }
 
        Delegate &operator=(const Delegate &other)
        {
            if (this == &other) {
                return *this;
            }
 
            CallableList<TRet(Args...)> copied;
 
            for (size_t i = 0; i < other._data.Count(); ++i) {
                copied.Add(other._data[i]->Clone());
            }
            _data = std::move(copied);
            return *this;
        }
 
        Delegate &operator=(Delegate &&other) noexcept
        {
            if (this != &other) {
                _data = std::move(other._data);
            }
            return *this;
        }
 
        void Add(const ICallable<TRet(Args...)> &callable)
        {
            if (callable.GetType() == GetType()) {
                auto &delegate = static_cast<const Delegate &>(callable);
                if (delegate._data.IsEmpty()) {
                    return;
                } else if (delegate._data.Count() == 1) {
                    _data.Add(delegate._data[0]->Clone());
                    return;
                }
            }
            _data.Add(callable.Clone());
        }
 
        void Add(TRet (*func)(Args...))
        {
            if (func != nullptr) {
                _data.Add(new _CallableWrapper<decltype(func)>(func));
            }
        }
 
        template <typename T>
        auto Add(const T &callable)
            -> typename std::enable_if<!std::is_base_of<_ICallable, T>::value, void>::type
        {
            _data.Add(new _CallableWrapper<T>(callable));
        }
 
        template <typename T>
        void Add(T &obj, TRet (T::*func)(Args...))
        {
            _data.Add(new _MemberFuncWrapper<T>(obj, func));
        }
 
        template <typename T>
        void Add(const T &obj, TRet (T::*func)(Args...) const)
        {
            _data.Add(new _ConstMemberFuncWrapper<T>(obj, func));
        }
 
        void Clear()
        {
            _data.Clear();
        }
 
        bool Remove(const ICallable<TRet(Args...)> &callable)
        {
            if (callable.GetType() == GetType()) {
                auto &delegate = static_cast<const Delegate &>(callable);
                if (delegate._data.IsEmpty()) {
                    return false;
                } else if (delegate._data.Count() == 1) {
                    return _Remove(*delegate._data[0]);
                }
            }
            return _Remove(callable);
        }
 
        bool Remove(TRet (*func)(Args...))
        {
            if (func == nullptr) {
                return false;
            }
            return _Remove(_CallableWrapper<decltype(func)>(func));
        }
 
        template <typename T>
        auto Remove(const T &callable)
            -> typename std::enable_if<!std::is_base_of<_ICallable, T>::value, bool>::type
        {
            return _Remove(_CallableWrapper<T>(callable));
        }
 
        template <typename T>
        bool Remove(T &obj, TRet (T::*func)(Args...))
        {
            return _Remove(_MemberFuncWrapper<T>(obj, func));
        }
 
        template <typename T>
        bool Remove(const T &obj, TRet (T::*func)(Args...) const)
        {
            return _Remove(_ConstMemberFuncWrapper<T>(obj, func));
        }
 
        TRet operator()(Args... args) const
        {
            return _InvokeImpl(std::forward<Args>(args)...);
        }
 
        bool operator==(const Delegate &other) const
        {
            return Equals(other);
        }
 
        bool operator!=(const Delegate &other) const
        {
            return !Equals(other);
        }
 
        bool operator==(std::nullptr_t) const noexcept
        {
            return _data.IsEmpty();
        }
 
        bool operator!=(std::nullptr_t) const noexcept
        {
            return !_data.IsEmpty();
        }
 
        explicit operator bool() const noexcept
        {
            return !_data.IsEmpty();
        }
 
        Delegate &operator+=(const ICallable<TRet(Args...)> &callable)
        {
            Add(callable);
            return *this;
        }
 
        Delegate &operator+=(TRet (*func)(Args...))
        {
            Add(func);
            return *this;
        }
 
        template <typename T>
        auto operator+=(const T &callable)
            -> typename std::enable_if<!std::is_base_of<_ICallable, T>::value, Delegate &>::type
        {
            Add(callable);
            return *this;
        }
 
        Delegate &operator-=(const ICallable<TRet(Args...)> &callable)
        {
            Remove(callable);
            return *this;
        }
 
        Delegate &operator-=(TRet (*func)(Args...))
        {
            Remove(func);
            return *this;
        }
 
        template <typename T>
        auto operator-=(const T &callable)
            -> typename std::enable_if<!std::is_base_of<_ICallable, T>::value, Delegate &>::type
        {
            Remove(callable);
            return *this;
        }
 
        virtual TRet Invoke(Args... args) const override
        {
            return _InvokeImpl(std::forward<Args>(args)...);
        }
 
        virtual ICallable<TRet(Args...)> *Clone() const override
        {
            return new Delegate(*this);
        }
 
        virtual std::type_index GetType() const override
        {
            return typeid(Delegate<TRet(Args...)>);
        }
 
        virtual bool Equals(const ICallable<TRet(Args...)> &other) const override
        {
            if (this == &other) {
                return true;
            }
            if (GetType() != other.GetType()) {
                return false;
            }
            const auto &otherDelegate = static_cast<const Delegate &>(other);
            if (_data.Count() != otherDelegate._data.Count()) {
                return false;
            }
            for (size_t i = _data.Count(); i > 0; --i) {
                if (!_data[i - 1]->Equals(*otherDelegate._data[i - 1])) {
                    return false;
                }
            }
            return true;
        }
 
        template <typename U = TRet>
        auto InvokeAll(Args... args) const
            -> typename std::enable_if<!std::is_void<U>::value, std::vector<U>>::type
        {
            std::vector<U> results;
            size_t count = _data.Count();
            if (count == 0) {
                _ThrowEmptyDelegateError();
            } else if (count == 1) {
                results.emplace_back(_data[0]->Invoke(std::forward<Args>(args)...));
            } else {
                auto list = _data;
                results.reserve(count);
                for (size_t i = 0; i + 1 < count; ++i) {
                    results.emplace_back(list[i]->Invoke(args...));
                }
                results.emplace_back(list[count - 1]->Invoke(std::forward<Args>(args)...));
            }
            return results;
        }
 
    private:
        bool _Remove(const _ICallable &callable)
        {
            for (size_t i = _data.Count(); i > 0; --i) {
                if (_data[i - 1]->Equals(callable)) {
                    return _data.RemoveAt(i - 1);
                }
            }
            return false;
        }
 
        [[noreturn]] void _ThrowEmptyDelegateError() const
        {
            throw std::runtime_error("Delegate is empty");
        }
 
        inline TRet _InvokeImpl(Args... args) const
        {
            size_t count = _data.Count();
            if (count == 0) {
                _ThrowEmptyDelegateError();
            } else if (count == 1) {
                return _data[0]->Invoke(std::forward<Args>(args)...);
            } else {
                auto list = _data;
                for (size_t i = 0; i + 1 < count; ++i)
                    list[i]->Invoke(args...);
                return list[count - 1]->Invoke(std::forward<Args>(args)...);
            }
        }
    };
 
    /*================================================================================*/
 
    template <typename TRet, typename... Args>
    inline bool operator==(std::nullptr_t, const Delegate<TRet(Args...)> &d) noexcept
    {
        return d == nullptr;
    }
 
    template <typename TRet, typename... Args>
    inline bool operator!=(std::nullptr_t, const Delegate<TRet(Args...)> &d) noexcept
    {
        return d != nullptr;
    }
 
    /*================================================================================*/
 
    template <typename... Args>
    using Action = Delegate<void(Args...)>;
 
    template <typename T>
    using Predicate = Delegate<bool(T)>;
 
    /*================================================================================*/
 
    template <typename...>
    struct _FuncTraits;
 
    template <typename Last>
    struct _FuncTraits<Last> {
        using TRet       = Last;
        using TArgsTuple = std::tuple<>;
    };
 
    template <typename First, typename... Rest>
    struct _FuncTraits<First, Rest...> {
        using TRet       = typename _FuncTraits<Rest...>::TRet;
        using TArgsTuple = decltype(std::tuple_cat(std::declval<std::tuple<First>>(), std::declval<typename _FuncTraits<Rest...>::TArgsTuple>()));
    };
 
    template <typename TArgsTuple>
    struct _FuncTypeHelper;
 
    template <typename... Args>
    struct _FuncTypeHelper<std::tuple<Args...>> {
        template <typename TRet>
        using TFunc = Delegate<TRet(Args...)>;
    };
 
    template <typename... Types>
    using Func = typename _FuncTypeHelper<typename _FuncTraits<Types...>::TArgsTuple>::template TFunc<typename _FuncTraits<Types...>::TRet>;
}