Reflection.h

#pragma once
 
// 定义_SW_DISABLE_REFLECTION可以禁用反射相关功能
// 若该宏被定义，则相关功能会抛出runtime_error异常
// #define _SW_DISABLE_REFLECTION
 
#include "Delegate.h"
#include "IComparable.h"
#include "IToString.h"
#include "Property.h"
#include <type_traits>
#include <typeindex>
 
namespace sw
{
    template <typename TFrom, typename TTo>
    using _IsStaticCastable = _IsExplicitlyConvertable<TFrom, TTo>;
 
    class DynamicObject
    {
    public:
        virtual ~DynamicObject() = default;
 
        std::type_index GetTypeIndex() const
        {
#if defined(_SW_DISABLE_REFLECTION)
            throw std::runtime_error("Reflection is disabled, cannot get type index.");
#else
            return typeid(*this);
#endif
        }
 
        template <typename T>
        bool IsType(T **pout = nullptr)
        {
#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>
        bool IsType(const T **pout = nullptr) const
        {
#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>
        T &DynamicCast()
        {
#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>
        const T &DynamicCast() const
        {
#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<_IsStaticCastable<DynamicObject *, T *>::value, T &>::type
        {
            return static_cast<T &>(*this);
        }
 
        template <typename T>
        auto UnsafeCast()
            -> typename std::enable_if<!_IsStaticCastable<DynamicObject *, T *>::value, T &>::type
        {
            return DynamicCast<T>();
        }
 
        template <typename T>
        auto UnsafeCast() const
            -> typename std::enable_if<_IsStaticCastable<DynamicObject *, T *>::value, const T &>::type
        {
            return static_cast<const T &>(*this);
        }
 
        template <typename T>
        auto UnsafeCast() const
            -> typename std::enable_if<!_IsStaticCastable<DynamicObject *, T *>::value, const T &>::type
        {
            return DynamicCast<T>();
        }
    };
 
    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;
 
        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...))
            -> typename std::enable_if<
                std::is_base_of<DynamicObject, T>::value, Delegate<TRet(DynamicObject &, Args...)>>::type
        {
            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)
            -> typename std::enable_if<
                std::is_base_of<DynamicObject, T>::value, Delegate<TRet(DynamicObject &, Args...)>>::type
        {
            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)
            -> typename std::enable_if<
                std::is_base_of<DynamicObject, T>::value, Delegate<TField &(DynamicObject &)>>::type
        {
            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<
                std::is_base_of<DynamicObject, T>::value && _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<
                std::is_base_of<DynamicObject, T>::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<
                std::is_base_of<DynamicObject, T>::value && _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<
                std::is_base_of<DynamicObject, T>::value && !_IsWritableProperty<TProperty>::value,
                Delegate<void(DynamicObject &, typename TProperty::TSetterParam)>>::type
        {
            return nullptr;
        }
    };
}
 
// 为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);
    }
};