Reflection.h

#pragma once
 
// 定义SW_DISABLE_REFLECTION可以禁用反射相关功能
// 若该宏被定义，则相关功能会抛出runtime_error异常
// #define SW_DISABLE_REFLECTION
 
#include "Delegate.h"
#include "IComparable.h"
#include "IToString.h"
#include "Internal.h"
#include "Property.h"
#include <type_traits>
#include <typeindex>
 
namespace sw
{
    template <typename T, typename = void>
    class BoxedObject;
 
    class DynamicObject
    {
    private:
        template <typename, typename>
        friend class BoxedObject;
 
        bool _isBoxedObject;
 
    public:
        DynamicObject() noexcept
            : _isBoxedObject(false)
        {
        }
 
        virtual ~DynamicObject()
        {
        }
 
        bool IsBoxedObject() const noexcept
        {
            return _isBoxedObject;
        }
 
        bool ReferenceEquals(const DynamicObject &other) const noexcept
        {
            if (this == &other) {
                return true;
            }
            if (IsBoxedObject() && other.IsBoxedObject()) {
                return GetBoxedRawPtr() == other.GetBoxedRawPtr();
            }
            return false;
        }
 
        std::type_index GetType() const noexcept
        {
#if defined(SW_DISABLE_REFLECTION)
            throw std::runtime_error("Reflection is disabled, cannot get type index.");
#else
            if (IsBoxedObject()) {
                return GetBoxedType();
            } else {
                return typeid(*this);
            }
#endif
        }
 
        template <typename T>
        auto IsType(T **pout = nullptr)
            -> typename std::enable_if<std::is_base_of<DynamicObject, T>::value, bool>::type
        {
#if defined(SW_DISABLE_REFLECTION)
            throw std::runtime_error("Reflection is disabled, cannot check type.");
#else
            if (pout == nullptr) {
                return dynamic_cast<T *>(this) != nullptr;
            } else {
                *pout = dynamic_cast<T *>(this);
                return *pout != nullptr;
            }
#endif
        }
 
        template <typename T>
        auto IsType(const T **pout = nullptr) const
            -> typename std::enable_if<std::is_base_of<DynamicObject, T>::value, bool>::type
        {
#if defined(SW_DISABLE_REFLECTION)
            throw std::runtime_error("Reflection is disabled, cannot check type.");
#else
            if (pout == nullptr) {
                return dynamic_cast<const T *>(this) != nullptr;
            } else {
                *pout = dynamic_cast<const T *>(this);
                return *pout != nullptr;
            }
#endif
        }
 
        template <typename T>
        auto DynamicCast()
            -> typename std::enable_if<std::is_base_of<DynamicObject, T>::value, T &>::type
        {
#if defined(SW_DISABLE_REFLECTION)
            throw std::runtime_error("Reflection is disabled, cannot perform dynamic cast.");
#else
            return dynamic_cast<T &>(*this);
#endif
        }
 
        template <typename T>
        auto DynamicCast() const
            -> typename std::enable_if<std::is_base_of<DynamicObject, T>::value, const T &>::type
        {
#if defined(SW_DISABLE_REFLECTION)
            throw std::runtime_error("Reflection is disabled, cannot perform dynamic cast.");
#else
            return dynamic_cast<const T &>(*this);
#endif
        }
 
        template <typename T>
        auto UnsafeCast()
            -> typename std::enable_if<
                std::is_base_of<DynamicObject, T>::value && _IsStaticCastable<DynamicObject *, T *>::value, T &>::type
        {
            return static_cast<T &>(*this);
        }
 
        template <typename T>
        auto UnsafeCast()
            -> typename std::enable_if<
                std::is_base_of<DynamicObject, T>::value && !_IsStaticCastable<DynamicObject *, T *>::value, T &>::type
        {
            return DynamicCast<T>();
        }
 
        template <typename T>
        auto UnsafeCast() const
            -> typename std::enable_if<
                std::is_base_of<DynamicObject, T>::value && _IsStaticCastable<DynamicObject *, T *>::value, const T &>::type
        {
            return static_cast<const T &>(*this);
        }
 
        template <typename T>
        auto UnsafeCast() const
            -> typename std::enable_if<
                std::is_base_of<DynamicObject, T>::value && !_IsStaticCastable<DynamicObject *, T *>::value, const T &>::type
        {
            return DynamicCast<T>();
        }
 
    public:
        template <typename T>
        auto IsType(T **pout = nullptr)
            -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && _IsDynamicCastable<DynamicObject *, T *>::value, bool>::type;
 
        template <typename T>
        auto IsType(T **pout = nullptr)
            -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && !_IsDynamicCastable<DynamicObject *, T *>::value, bool>::type;
 
        template <typename T>
        auto IsType(const T **pout = nullptr) const
            -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && _IsDynamicCastable<DynamicObject *, T *>::value, bool>::type;
 
        template <typename T>
        auto IsType(const T **pout = nullptr) const
            -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && !_IsDynamicCastable<DynamicObject *, T *>::value, bool>::type;
 
        template <typename T>
        auto DynamicCast()
            -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && _IsDynamicCastable<DynamicObject *, T *>::value, T &>::type;
 
        template <typename T>
        auto DynamicCast()
            -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && !_IsDynamicCastable<DynamicObject *, T *>::value, T &>::type;
 
        template <typename T>
        auto DynamicCast() const
            -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && _IsDynamicCastable<DynamicObject *, T *>::value, const T &>::type;
 
        template <typename T>
        auto DynamicCast() const
            -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && !_IsDynamicCastable<DynamicObject *, T *>::value, const T &>::type;
 
        template <typename T>
        auto UnsafeCast()
            -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && _IsStaticCastable<DynamicObject *, T *>::value, T &>::type;
 
        template <typename T>
        auto UnsafeCast()
            -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && !_IsStaticCastable<DynamicObject *, T *>::value, T &>::type;
 
        template <typename T>
        auto UnsafeCast() const
            -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && _IsStaticCastable<DynamicObject *, T *>::value, const T &>::type;
 
        template <typename T>
        auto UnsafeCast() const
            -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && !_IsStaticCastable<DynamicObject *, T *>::value, const T &>::type;
 
    private:
        virtual std::type_index GetBoxedType() const noexcept
        {
            return typeid(void);
        }
 
        virtual bool IsBoxedPolymorphic() const noexcept
        {
            return false;
        }
 
        virtual void *GetBoxedRawPtr() noexcept
        {
            return nullptr;
        }
 
        virtual const void *GetBoxedRawPtr() const noexcept
        {
            return nullptr;
        }
    };
 
    /*================================================================================*/
 
    template <typename T>
    class BoxedObject<T, typename std::enable_if<!std::is_base_of<DynamicObject, T>::value>::type> final
        : public DynamicObject
    {
        struct _IsRefParam {
            bool val;
        };
 
        template <typename U, typename = void>
        union _InternalData {
            U *refptr;
 
            alignas(U) uint8_t objbuf[sizeof(U)];
        };
 
        template <typename U>
        union _InternalData<U, typename std::enable_if<std::is_abstract<U>::value>::type> {
            U *refptr;
 
            uint8_t objbuf[1];
        };
 
    private:
        bool _isRef;
 
        _InternalData<T> _data;
 
    private:
        explicit BoxedObject(_IsRefParam isRef) noexcept
            : _isRef(isRef.val), _data()
        {
            _isBoxedObject = true;
        }
 
        void Release() noexcept(std::is_nothrow_destructible<T>::value)
        {
            if (!_isRef) {
                Unbox().~T();
            }
        }
 
        template <typename U = T>
        auto NotRefCopyConstructImpl(const BoxedObject &other) noexcept(std::is_nothrow_copy_constructible<U>::value)
            -> typename std::enable_if<std::is_copy_constructible<U>::value>::type
        {
            new (_data.objbuf) T(other.Unbox());
        }
 
        template <typename U = T>
        auto NotRefCopyConstructImpl(const BoxedObject &other) noexcept(false)
            -> typename std::enable_if<!std::is_copy_constructible<U>::value>::type
        {
            throw std::logic_error("Type T must be copy constructible to copy construct a non-ref BoxedObject.");
        }
 
        template <typename U = T>
        auto NotRefMoveConstructImpl(BoxedObject &&other) noexcept(std::is_nothrow_move_constructible<U>::value)
            -> typename std::enable_if<std::is_move_constructible<U>::value>::type
        {
            new (_data.objbuf) T(std::move(other.Unbox()));
        }
 
        template <typename U = T>
        auto NotRefMoveConstructImpl(BoxedObject &&other) noexcept(false)
            -> typename std::enable_if<!std::is_move_constructible<U>::value>::type
        {
            throw std::logic_error("Type T must be move constructible to move construct a non-ref BoxedObject.");
        }
 
        template <typename U = T>
        auto NotRefCopyAssignImpl(const BoxedObject &other)
            -> typename std::enable_if<std::is_copy_assignable<U>::value>::type
        {
            if (other._isRef) {
                Release();
                _data.refptr = other._data.refptr;
                _isRef       = true;
            } else {
                Unbox() = other.Unbox();
            }
        }
 
        template <typename U = T>
        auto NotRefCopyAssignImpl(const BoxedObject &other)
            -> typename std::enable_if<!std::is_copy_assignable<U>::value>::type
        {
            if (other._isRef) {
                Release();
                _data.refptr = other._data.refptr;
                _isRef       = true;
            } else {
                throw std::logic_error("Type T must be copy assignable to copy assign a non-ref BoxedObject.");
            }
        }
 
        template <typename U = T>
        auto NotRefMoveAssignImpl(BoxedObject &&other)
            -> typename std::enable_if<std::is_move_assignable<U>::value>::type
        {
            if (other._isRef) {
                Release();
                _data.refptr       = other._data.refptr;
                _isRef             = true;
                other._data.refptr = nullptr;
            } else {
                Unbox() = std::move(other.Unbox());
            }
        }
 
        template <typename U = T>
        auto NotRefMoveAssignImpl(BoxedObject &&other)
            -> typename std::enable_if<!std::is_move_assignable<U>::value>::type
        {
            if (other._isRef) {
                Release();
                _data.refptr       = other._data.refptr;
                _isRef             = true;
                other._data.refptr = nullptr;
            } else {
                throw std::logic_error("Type T must be move assignable to move assign a non-ref BoxedObject.");
            }
        }
 
    public:
        template <typename... Args>
        BoxedObject(Args &&...args)
            : BoxedObject(_IsRefParam{false})
        {
            new (_data.objbuf) T(std::forward<Args>(args)...);
        }
 
        virtual ~BoxedObject()
        {
            Release();
        }
 
        static BoxedObject<T> MakeRef(T *ptr) noexcept
        {
            BoxedObject<T> result{_IsRefParam{true}};
            result._data.refptr = ptr;
            return result;
        }
 
        static BoxedObject<T> MakeRef(T &ref) noexcept
        {
            return MakeRef(&ref);
        }
 
        template <typename U>
        static auto MakeRef(BoxedObject<U> &other) noexcept
            -> typename std::enable_if<_IsStaticCastable<U, T>::value, BoxedObject<T>>::type
        {
            BoxedObject<T> result{_IsRefParam{true}};
            result._data.refptr = other.IsNullRef() ? nullptr : static_cast<T *>(&other.Unbox());
            return result;
        }
 
        BoxedObject(const BoxedObject &other) noexcept(std::is_nothrow_copy_constructible<T>::value)
            : BoxedObject(_IsRefParam{other._isRef})
        {
            if (_isRef) {
                _data.refptr = other._data.refptr;
            } else {
                NotRefCopyConstructImpl(other);
            }
        }
 
        BoxedObject(BoxedObject &&other) noexcept(std::is_nothrow_move_constructible<T>::value)
            : BoxedObject(_IsRefParam{other._isRef})
        {
            if (_isRef) {
                _data.refptr       = other._data.refptr;
                other._data.refptr = nullptr;
            } else {
                NotRefMoveConstructImpl(std::move(other));
            }
        }
 
        BoxedObject &operator=(const BoxedObject &other)
        {
            if (this == &other)
                return *this;
 
            if (_isRef) {
                if (other._isRef) {
                    _data.refptr = other._data.refptr;
                } else {
                    auto oldPtr = _data.refptr;
                    try {
                        NotRefCopyConstructImpl(other);
                        _isRef = false;
                    } catch (...) {
                        _data.refptr = oldPtr;
                        throw;
                    }
                }
            } else {
                NotRefCopyAssignImpl(other);
            }
            return *this;
        }
 
        BoxedObject &operator=(BoxedObject &&other)
        {
            if (this == &other)
                return *this;
 
            if (_isRef) {
                if (other._isRef) {
                    _data.refptr       = other._data.refptr;
                    other._data.refptr = nullptr;
                } else {
                    auto oldPtr = _data.refptr;
                    try {
                        NotRefMoveConstructImpl(std::move(other));
                        _isRef = false;
                    } catch (...) {
                        _data.refptr = oldPtr;
                        throw;
                    }
                }
            } else {
                NotRefMoveAssignImpl(std::move(other));
            }
            return *this;
        }
 
        bool IsRef() const noexcept
        {
            return _isRef;
        }
 
        bool IsNullRef() const noexcept
        {
            return _isRef && (_data.refptr == nullptr);
        }
 
        bool HasValue() const noexcept
        {
            return !IsNullRef();
        }
 
        T &Unbox() noexcept
        {
            assert(HasValue());
            return _isRef ? *_data.refptr : *reinterpret_cast<T *>(_data.objbuf);
        }
 
        const T &Unbox() const noexcept
        {
            assert(HasValue());
            return _isRef ? *_data.refptr : *reinterpret_cast<const T *>(_data.objbuf);
        }
 
    private:
        virtual std::type_index GetBoxedType() const noexcept override
        {
            return typeid(T);
        }
 
        virtual bool IsBoxedPolymorphic() const noexcept override
        {
            return std::is_polymorphic<T>::value;
        }
 
        virtual void *GetBoxedRawPtr() noexcept override
        {
            // 当T带const时，refptr无法直接转换为void*，需要先转换为const void*再去掉const
            return const_cast<void *>(
                _isRef ? static_cast<const void *>(_data.refptr) : static_cast<const void *>(_data.objbuf));
        }
 
        virtual const void *GetBoxedRawPtr() const noexcept override
        {
            return _isRef ? static_cast<const void *>(_data.refptr) : static_cast<const void *>(_data.objbuf);
        }
    };
 
    /*================================================================================*/
 
    template <typename T>
    auto DynamicObject::IsType(T **pout)
        -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && _IsDynamicCastable<DynamicObject *, T *>::value, bool>::type
    {
#if defined(SW_DISABLE_REFLECTION)
        throw std::runtime_error("Reflection is disabled, cannot check type.");
#else
        if (!_isBoxedObject) {
            if (pout == nullptr) {
                return dynamic_cast<T *>(this) != nullptr;
            } else {
                *pout = dynamic_cast<T *>(this);
                return *pout != nullptr;
            }
        } else {
            if (GetBoxedType() == typeid(T)) {
                if (pout == nullptr) {
                    return GetBoxedRawPtr() != nullptr;
                } else {
                    *pout = static_cast<T *>(GetBoxedRawPtr());
                    return *pout != nullptr;
                }
            } else {
                if (pout != nullptr) {
                    *pout = nullptr;
                }
                return false;
            }
        }
#endif
    }
 
    template <typename T>
    auto DynamicObject::IsType(T **pout)
        -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && !_IsDynamicCastable<DynamicObject *, T *>::value, bool>::type
    {
#if defined(SW_DISABLE_REFLECTION)
        throw std::runtime_error("Reflection is disabled, cannot check type.");
#else
        if (!_isBoxedObject) {
            if (pout != nullptr) {
                *pout = nullptr;
            }
            return false;
        } else {
            if (GetBoxedType() == typeid(T)) {
                if (pout == nullptr) {
                    return GetBoxedRawPtr() != nullptr;
                } else {
                    *pout = static_cast<T *>(GetBoxedRawPtr());
                    return *pout != nullptr;
                }
            } else {
                if (pout != nullptr) {
                    *pout = nullptr;
                }
                return false;
            }
        }
#endif
    }
 
    template <typename T>
    auto DynamicObject::IsType(const T **pout) const
        -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && _IsDynamicCastable<DynamicObject *, T *>::value, bool>::type
    {
#if defined(SW_DISABLE_REFLECTION)
        throw std::runtime_error("Reflection is disabled, cannot check type.");
#else
        if (!_isBoxedObject) {
            if (pout == nullptr) {
                return dynamic_cast<const T *>(this) != nullptr;
            } else {
                *pout = dynamic_cast<const T *>(this);
                return *pout != nullptr;
            }
        } else {
            if (GetBoxedType() == typeid(T)) {
                if (pout == nullptr) {
                    return GetBoxedRawPtr() != nullptr;
                } else {
                    *pout = static_cast<const T *>(GetBoxedRawPtr());
                    return *pout != nullptr;
                }
            } else {
                if (pout != nullptr) {
                    *pout = nullptr;
                }
                return false;
            }
        }
#endif
    }
 
    template <typename T>
    auto DynamicObject::IsType(const T **pout) const
        -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && !_IsDynamicCastable<DynamicObject *, T *>::value, bool>::type
    {
#if defined(SW_DISABLE_REFLECTION)
        throw std::runtime_error("Reflection is disabled, cannot check type.");
#else
        if (!_isBoxedObject) {
            if (pout != nullptr) {
                *pout = nullptr;
            }
            return false;
        } else {
            if (GetBoxedType() == typeid(T)) {
                if (pout == nullptr) {
                    return GetBoxedRawPtr() != nullptr;
                } else {
                    *pout = static_cast<const T *>(GetBoxedRawPtr());
                    return *pout != nullptr;
                }
            } else {
                if (pout != nullptr) {
                    *pout = nullptr;
                }
                return false;
            }
        }
#endif
    }
 
    template <typename T>
    auto DynamicObject::DynamicCast()
        -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && _IsDynamicCastable<DynamicObject *, T *>::value, T &>::type
    {
#if defined(SW_DISABLE_REFLECTION)
        throw std::runtime_error("Reflection is disabled, cannot perform dynamic cast.");
#else
        if (!_isBoxedObject) {
            return dynamic_cast<T &>(*this);
        } else {
            void *rawPtr = GetBoxedRawPtr();
            if (rawPtr == nullptr || GetBoxedType() != typeid(T)) {
                throw std::bad_cast();
            } else {
                return *static_cast<T *>(rawPtr);
            }
        }
#endif
    }
 
    template <typename T>
    auto DynamicObject::DynamicCast()
        -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && !_IsDynamicCastable<DynamicObject *, T *>::value, T &>::type
    {
#if defined(SW_DISABLE_REFLECTION)
        throw std::runtime_error("Reflection is disabled, cannot perform dynamic cast.");
#else
        if (!_isBoxedObject) {
            throw std::bad_cast();
        } else {
            void *rawPtr = GetBoxedRawPtr();
            if (rawPtr == nullptr || GetBoxedType() != typeid(T)) {
                throw std::bad_cast();
            } else {
                return *static_cast<T *>(rawPtr);
            }
        }
#endif
    }
 
    template <typename T>
    auto DynamicObject::DynamicCast() const
        -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && _IsDynamicCastable<DynamicObject *, T *>::value, const T &>::type
    {
#if defined(SW_DISABLE_REFLECTION)
        throw std::runtime_error("Reflection is disabled, cannot perform dynamic cast.");
#else
        if (!_isBoxedObject) {
            return dynamic_cast<const T &>(*this);
        } else {
            const void *rawPtr = GetBoxedRawPtr();
            if (rawPtr == nullptr || GetBoxedType() != typeid(T)) {
                throw std::bad_cast();
            } else {
                return *static_cast<const T *>(rawPtr);
            }
        }
#endif
    }
 
    template <typename T>
    auto DynamicObject::DynamicCast() const
        -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && !_IsDynamicCastable<DynamicObject *, T *>::value, const T &>::type
    {
#if defined(SW_DISABLE_REFLECTION)
        throw std::runtime_error("Reflection is disabled, cannot perform dynamic cast.");
#else
        if (!_isBoxedObject) {
            throw std::bad_cast();
        } else {
            const void *rawPtr = GetBoxedRawPtr();
            if (rawPtr == nullptr || GetBoxedType() != typeid(T)) {
                throw std::bad_cast();
            } else {
                return *static_cast<const T *>(rawPtr);
            }
        }
#endif
    }
 
    template <typename T>
    auto DynamicObject::UnsafeCast()
        -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && _IsStaticCastable<DynamicObject *, T *>::value, T &>::type
    {
        if (!_isBoxedObject) {
            return static_cast<T &>(*this);
        } else {
            return static_cast<BoxedObject<T> &>(*this).Unbox();
        }
    }
 
    template <typename T>
    auto DynamicObject::UnsafeCast()
        -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && !_IsStaticCastable<DynamicObject *, T *>::value, T &>::type
    {
        if (!_isBoxedObject) {
            return DynamicCast<T>();
        } else {
            return static_cast<BoxedObject<T> &>(*this).Unbox();
        }
    }
 
    template <typename T>
    auto DynamicObject::UnsafeCast() const
        -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && _IsStaticCastable<DynamicObject *, T *>::value, const T &>::type
    {
        if (!_isBoxedObject) {
            return static_cast<const T &>(*this);
        } else {
            return static_cast<const BoxedObject<T> &>(*this).Unbox();
        }
    }
 
    template <typename T>
    auto DynamicObject::UnsafeCast() const
        -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value && !_IsStaticCastable<DynamicObject *, T *>::value, const T &>::type
    {
        if (!_isBoxedObject) {
            return DynamicCast<T>();
        } else {
            return static_cast<const BoxedObject<T> &>(*this).Unbox();
        }
    }
 
    /*================================================================================*/
 
    struct FieldId : public IToString<FieldId>,
                     public IComparable<FieldId, FieldId> {
        uint32_t value;
 
        FieldId() = default;
 
        FieldId(uint32_t value)
            : value(value)
        {
        }
 
        std::wstring ToString() const
        {
            return std::to_wstring(value);
        }
 
        int CompareTo(FieldId other) const
        {
            if (value == other.value) {
                return 0;
            } else {
                return value < other.value ? -1 : 1;
            }
        }
    };
 
    /*================================================================================*/
 
    class Reflection
    {
    public:
        Reflection() = delete;
 
    public:
        template <typename T, typename TField>
        static FieldId GetFieldId(TField T::*field) noexcept
        {
            auto pfunc = &Reflection::GetFieldId<T, TField>;
 
            uint8_t buffer[sizeof(pfunc) + sizeof(field)];
            memcpy(buffer, &pfunc, sizeof(pfunc));
            memcpy(buffer + sizeof(pfunc), &field, sizeof(field));
 
            uint32_t prime = 16777619u;
            uint32_t hash  = 2166136261u;
 
            for (size_t i = 0; i < sizeof(buffer); ++i) {
                hash ^= static_cast<uint32_t>(buffer[i]);
                hash *= prime;
            }
 
            return FieldId{hash};
        }
 
        template <typename T, typename TRet, typename... Args>
        static auto GetMethod(TRet (T::*method)(Args...)) -> Delegate<TRet(DynamicObject &, Args...)>
        {
            return [method](DynamicObject &obj, Args... args) -> TRet {
                return (obj.UnsafeCast<T>().*method)(std::forward<Args>(args)...);
            };
        }
 
        template <typename T, typename TRet, typename... Args>
        static auto GetMethod(TRet (T::*method)(Args...) const) -> Delegate<TRet(DynamicObject &, Args...)>
        {
            return [method](DynamicObject &obj, Args... args) -> TRet {
                return (obj.UnsafeCast<T>().*method)(std::forward<Args>(args)...);
            };
        }
 
        template <typename T, typename TField>
        static auto GetFieldAccessor(TField T::*field) -> Delegate<TField &(DynamicObject &)>
        {
            return [field](DynamicObject &obj) -> TField & {
                return obj.UnsafeCast<T>().*field;
            };
        }
 
        template <typename T, typename TProperty>
        static auto GetPropertyGetter(TProperty T::*prop)
            -> typename std::enable_if<
                _IsReadableProperty<TProperty>::value,
                Delegate<typename TProperty::TValue(DynamicObject &)>>::type
        {
            return [prop](DynamicObject &obj) -> typename TProperty::TValue {
                return (obj.UnsafeCast<T>().*prop).Get();
            };
        }
 
        template <typename T, typename TProperty>
        static auto GetPropertyGetter(TProperty T::*prop)
            -> typename std::enable_if<
                _IsProperty<TProperty>::value && !_IsReadableProperty<TProperty>::value,
                Delegate<typename TProperty::TValue(DynamicObject &)>>::type
        {
            return nullptr;
        }
 
        template <typename T, typename TProperty>
        static auto GetPropertySetter(TProperty T::*prop)
            -> typename std::enable_if<
                _IsWritableProperty<TProperty>::value,
                Delegate<void(DynamicObject &, typename TProperty::TSetterParam)>>::type
        {
            return [prop](DynamicObject &obj, typename TProperty::TSetterParam value) {
                (obj.UnsafeCast<T>().*prop).Set(std::forward<typename TProperty::TSetterParam>(value));
            };
        }
 
        template <typename T, typename TProperty>
        static auto GetPropertySetter(TProperty T::*prop)
            -> typename std::enable_if<
                _IsProperty<TProperty>::value && !_IsWritableProperty<TProperty>::value,
                Delegate<void(DynamicObject &, typename TProperty::TSetterParam)>>::type
        {
            return nullptr;
        }
 
    public:
        template <typename T, typename TFunc, typename... Args>
        static auto InvokeMethod(const Delegate<TFunc> &method, T &obj, Args &&...args)
            -> typename std::enable_if<std::is_base_of<DynamicObject, T>::value,
                                       decltype(method(obj, std::forward<Args>(args)...))>::type
        {
            assert(method != nullptr);
            return method(obj, std::forward<Args>(args)...);
        }
 
        template <typename T, typename TFunc, typename... Args>
        static auto InvokeMethod(const Delegate<TFunc> &method, T &obj, Args &&...args)
            -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value,
                                       decltype(method(std::declval<DynamicObject &>(), std::forward<Args>(args)...))>::type
        {
            assert(method != nullptr);
            auto boxed = BoxedObject<T>::MakeRef(obj);
            return method(boxed, std::forward<Args>(args)...);
        }
 
        template <typename T, typename TField>
        static auto AccessField(const Delegate<TField &(DynamicObject &)> &accessor, T &obj)
            -> typename std::enable_if<std::is_base_of<DynamicObject, T>::value, TField &>::type
        {
            assert(accessor != nullptr);
            return accessor(obj);
        }
 
        template <typename T, typename TField>
        static auto AccessField(const Delegate<TField &(DynamicObject &)> &accessor, T &obj)
            -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value, TField &>::type
        {
            assert(accessor != nullptr);
            auto boxed = BoxedObject<T>::MakeRef(obj);
            return accessor(boxed);
        }
 
        template <typename T, typename TValue>
        static auto GetProperty(const Delegate<TValue(DynamicObject &)> &getter, T &obj)
            -> typename std::enable_if<std::is_base_of<DynamicObject, T>::value, TValue>::type
        {
            assert(getter != nullptr);
            return getter(obj);
        }
 
        template <typename T, typename TValue>
        static auto GetProperty(const Delegate<TValue(DynamicObject &)> &getter, T &obj)
            -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value, TValue>::type
        {
            assert(getter != nullptr);
            auto boxed = BoxedObject<T>::MakeRef(obj);
            return getter(boxed);
        }
 
        template <typename T, typename TParam, typename TValue>
        static auto SetProperty(const Delegate<void(DynamicObject &, TParam)> &setter, T &obj, TValue &&value)
            -> typename std::enable_if<std::is_base_of<DynamicObject, T>::value>::type
        {
            assert(setter != nullptr);
            setter(obj, std::forward<TValue>(value));
        }
 
        template <typename T, typename TParam, typename TValue>
        static auto SetProperty(const Delegate<void(DynamicObject &, TParam)> &setter, T &obj, TValue &&value)
            -> typename std::enable_if<!std::is_base_of<DynamicObject, T>::value>::type
        {
            assert(setter != nullptr);
            auto boxed = BoxedObject<T>::MakeRef(obj);
            setter(boxed, std::forward<TValue>(value));
        }
    };
}
 
// 为sw::FieldId特化std::hash
template <>
struct std::hash<sw::FieldId> //
{
    size_t operator()(sw::FieldId fieldId) const noexcept
    {
        return static_cast<size_t>(fieldId.value);
    }
};