Property.h

#pragma once
 
#include "Internal.h"
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <type_traits>
#include <utility>
 
#define _SW_DEFINE_OPERATION_HELPER(NAME, OP)                                                    \
    template <typename T, typename U, typename = void>                                           \
    struct NAME : std::false_type {                                                              \
    };                                                                                           \
    template <typename T, typename U>                                                            \
    struct NAME<T, U, decltype(void(std::declval<T>() OP std::declval<U>()))> : std::true_type { \
        using type = decltype(std::declval<T>() OP std::declval<U>());                           \
    }
 
#define _SW_DEFINE_UNARY_OPERATION_HELPER(NAME, OP)                         \
    template <typename T, typename = void>                                  \
    struct NAME : std::false_type {                                         \
    };                                                                      \
    template <typename T>                                                   \
    struct NAME<T, decltype(void(OP std::declval<T>()))> : std::true_type { \
        using type = decltype(OP std::declval<T>());                        \
    }
 
namespace sw
{
    template <typename T, typename TDerived>
    class PropertyBase;
 
    template <typename T>
    class Property;
 
    template <typename T>
    class ReadOnlyProperty;
 
    template <typename T>
    class WriteOnlyProperty;
 
    /*================================================================================*/
 
    // SFINAE templates
    _SW_DEFINE_OPERATION_HELPER(_AddOperationHelper, +);
    _SW_DEFINE_OPERATION_HELPER(_SubOperationHelper, -);
    _SW_DEFINE_OPERATION_HELPER(_MulOperationHelper, *);
    _SW_DEFINE_OPERATION_HELPER(_DivOperationHelper, /);
    _SW_DEFINE_OPERATION_HELPER(_ModOperationHelper, %);
    _SW_DEFINE_OPERATION_HELPER(_EqOperationHelper, ==);
    _SW_DEFINE_OPERATION_HELPER(_NeOperationHelper, !=);
    _SW_DEFINE_OPERATION_HELPER(_LtOperationHelper, <);
    _SW_DEFINE_OPERATION_HELPER(_LeOperationHelper, <=);
    _SW_DEFINE_OPERATION_HELPER(_GtOperationHelper, >);
    _SW_DEFINE_OPERATION_HELPER(_GeOperationHelper, >=);
    _SW_DEFINE_OPERATION_HELPER(_BitAndOperationHelper, &);
    _SW_DEFINE_OPERATION_HELPER(_BitOrOperationHelper, |);
    _SW_DEFINE_OPERATION_HELPER(_BitXorOperationHelper, ^);
    _SW_DEFINE_OPERATION_HELPER(_ShlOperationHelper, <<);
    _SW_DEFINE_OPERATION_HELPER(_ShrOperationHelper, >>);
    _SW_DEFINE_OPERATION_HELPER(_LogicAndOperationHelper, &&);
    _SW_DEFINE_OPERATION_HELPER(_LogicOrOperationHelper, ||);
    _SW_DEFINE_UNARY_OPERATION_HELPER(_LogicNotOperationHelper, !);
    _SW_DEFINE_UNARY_OPERATION_HELPER(_BitNotOperationHelper, ~);
    _SW_DEFINE_UNARY_OPERATION_HELPER(_DerefOperationHelper, *);
    _SW_DEFINE_UNARY_OPERATION_HELPER(_AddrOperationHelper, &);
    _SW_DEFINE_UNARY_OPERATION_HELPER(_UnaryPlusOperationHelper, +);
    _SW_DEFINE_UNARY_OPERATION_HELPER(_UnaryMinusOperationHelper, -);
    // _SW_DEFINE_UNARY_OPERATION_HELPER(_PreIncOperationHelper, ++);
    // _SW_DEFINE_UNARY_OPERATION_HELPER(_PreDecOperationHelper, --);
 
    template <typename T>
    struct _IsPropertyImpl {
    private:
        template <typename U, typename V>
        static std::true_type test(const PropertyBase<U, V> *);
        static std::false_type test(...);
 
    public:
        using type = decltype(test(std::declval<T *>()));
    };
 
    template <typename T>
    struct _IsProperty : _IsPropertyImpl<typename std::decay<T>::type>::type {
    };
 
    template <typename, typename = void>
    struct _HasGetterImpl : std::false_type {
    };
 
    template <typename T>
    struct _HasGetterImpl<
        T, decltype(void(&T::GetterImpl))> : std::true_type {
    };
 
    template <typename, typename = void>
    struct _HasSetterImpl : std::false_type {
    };
 
    template <typename T>
    struct _HasSetterImpl<
        T, decltype(void(&T::SetterImpl))> : std::true_type {
    };
 
    template <typename T>
    struct _IsReadableProperty
        : std::integral_constant<bool, _IsProperty<T>::value && _HasGetterImpl<T>::value> {
    };
 
    template <typename T>
    struct _IsWritableProperty
        : std::integral_constant<bool, _IsProperty<T>::value && _HasSetterImpl<T>::value> {
    };
 
    template <typename T, typename U, typename = void>
    struct _BracketOperationHelper : std::false_type {
    };
 
    template <typename T, typename U>
    struct _BracketOperationHelper<
        T, U, decltype(void(std::declval<T>()[std::declval<U>()]))> : std::true_type {
        using type = decltype(std::declval<T>()[std::declval<U>()]);
    };
 
    template <typename T, typename = void>
    struct _HasArrowOperator : std::false_type {
    };
 
    template <typename T>
    struct _HasArrowOperator<
        T, decltype(void(std::declval<T>().operator->()))> : std::true_type {
        using type = decltype(std::declval<T>().operator->());
    };
 
    template <typename T>
    using _PropertySetterParamType = _OptimalParamType<T>;
 
    /*================================================================================*/
 
    template <typename T>
    struct FieldsAccessor {
        T value;
 
        template <typename... Args>
        FieldsAccessor(Args &&...args)
            : value(std::forward<Args>(args)...)
        {
        }
 
        template <typename U = T>
        typename std::enable_if<std::is_pointer<U>::value, U>::type operator->()
        {
            return this->value;
        }
 
        template <typename U = T>
        typename std::enable_if<!std::is_pointer<U>::value && !_HasArrowOperator<U>::value, U *>::type operator->()
        {
            return &this->value;
        }
 
        template <typename U = T>
        typename std::enable_if<!std::is_pointer<U>::value && _HasArrowOperator<U>::value, typename _HasArrowOperator<U>::type>::type operator->()
        {
            return this->value.operator->();
        }
    };
 
    template <typename TOwner, typename TValue>
    class MemberPropertyInitializer
    {
        friend class Property<TValue>;
        friend class ReadOnlyProperty<TValue>;
        friend class WriteOnlyProperty<TValue>;
 
    private:
        TOwner *_owner;
 
        TValue (*_getter)(TOwner *);
 
        void (*_setter)(TOwner *, _PropertySetterParamType<TValue>);
 
    public:
        MemberPropertyInitializer(TOwner *owner)
            : _owner(owner), _getter(nullptr), _setter(nullptr)
        {
        }
 
        MemberPropertyInitializer &Getter(TValue (*getter)(TOwner *))
        {
            this->_getter = getter;
            return *this;
        }
 
        MemberPropertyInitializer &Setter(void (*setter)(TOwner *, _PropertySetterParamType<TValue>))
        {
            this->_setter = setter;
            return *this;
        }
 
        template <TValue (TOwner::*getter)()>
        MemberPropertyInitializer &Getter()
        {
            return this->Getter(
                [](TOwner *owner) -> TValue {
                    return (owner->*getter)();
                });
        }
 
        template <TValue (TOwner::*getter)() const>
        MemberPropertyInitializer &Getter()
        {
            return this->Getter(
                [](TOwner *owner) -> TValue {
                    return (owner->*getter)();
                });
        }
 
        template <void (TOwner::*setter)(_PropertySetterParamType<TValue>)>
        MemberPropertyInitializer &Setter()
        {
            return this->Setter(
                [](TOwner *owner, _PropertySetterParamType<TValue> value) {
                    (owner->*setter)(value);
                });
        }
 
        template <void (TOwner::*setter)(_PropertySetterParamType<TValue>) const>
        MemberPropertyInitializer &Setter()
        {
            return this->Setter(
                [](TOwner *owner, _PropertySetterParamType<TValue> value) {
                    (owner->*setter)(value);
                });
        }
 
        template <TValue TOwner::*field>
        MemberPropertyInitializer &Getter()
        {
            return this->Getter(
                [](TOwner *owner) -> TValue {
                    return owner->*field;
                });
        }
 
        template <TValue TOwner::*field>
        MemberPropertyInitializer &Setter()
        {
            return this->Setter(
                [](TOwner *owner, _PropertySetterParamType<TValue> value) {
                    owner->*field = value;
                });
        }
    };
 
    template <typename TValue>
    class StaticPropertyInitializer
    {
        friend class Property<TValue>;
        friend class ReadOnlyProperty<TValue>;
        friend class WriteOnlyProperty<TValue>;
 
    private:
        TValue (*_getter)();
 
        void (*_setter)(_PropertySetterParamType<TValue>);
 
    public:
        StaticPropertyInitializer()
            : _getter(nullptr), _setter(nullptr)
        {
        }
 
        StaticPropertyInitializer &Getter(TValue (*getter)())
        {
            this->_getter = getter;
            return *this;
        }
 
        StaticPropertyInitializer &Setter(void (*setter)(_PropertySetterParamType<TValue>))
        {
            this->_setter = setter;
            return *this;
        }
    };
 
    /*================================================================================*/
 
    template <typename T, typename TDerived>
    class PropertyBase
    {
    public:
        // 属性值类型别名
        using TValue = T;
 
        // setter参数类型别名
        using TSetterParam = _PropertySetterParamType<T>;
 
        // /**
        //  * @brief 获取属性值，由子类实现
        //  */
        // T GetterImpl() const;
 
        // /**
        //  * @brief 设置属性值，由子类实现
        //  */
        // void SetterImpl(TSetterParam value) const;
 
        FieldsAccessor<T> AccessFields() const
        {
            return FieldsAccessor<T>(this->Get());
        }
 
        T Get() const
        {
            return static_cast<const TDerived *>(this)->GetterImpl();
        }
 
        void Set(TSetterParam value) const
        {
            static_cast<const TDerived *>(this)->SetterImpl(value);
        }
 
        auto operator->() const
        {
            return static_cast<const TDerived *>(this)->AccessFields();
        }
 
        operator T() const
        {
            return this->Get();
        }
 
        template <
            typename U = T,
            typename   = typename std::enable_if<!std::is_arithmetic<T>::value && std::is_convertible<T, U>::value, U>::type>
        operator U() const
        {
            return static_cast<U>(this->Get());
        }
 
        template <
            typename U = T,
            typename   = typename std::enable_if<!std::is_arithmetic<T>::value && !std::is_convertible<T, U>::value, U>::type,
            typename   = typename std::enable_if<!std::is_arithmetic<T>::value && _IsExplicitlyConvertable<T, U>::value, U>::type>
        explicit operator U() const
        {
            return static_cast<U>(this->Get());
        }
 
        TDerived &operator=(TSetterParam value)
        {
            this->Set(value);
            return *static_cast<TDerived *>(this);
        }
 
        const TDerived &operator=(TSetterParam value) const
        {
            this->Set(value);
            return *static_cast<const TDerived *>(this);
        }
 
        TDerived &operator=(const PropertyBase &prop)
        {
            this->Set(prop.Get());
            return *static_cast<TDerived *>(this);
        }
 
        const TDerived &operator=(const PropertyBase &prop) const
        {
            this->Set(prop.Get());
            return *static_cast<const TDerived *>(this);
        }
 
        template <typename U>
        auto operator+=(U &&value)
            -> typename std::enable_if<_AddOperationHelper<T, U>::value, TDerived &>::type
        {
            this->Set(this->Get() + std::forward<U>(value));
            return *static_cast<TDerived *>(this);
        }
 
        template <typename U>
        auto operator+=(U &&value) const
            -> typename std::enable_if<_AddOperationHelper<T, U>::value, const TDerived &>::type
        {
            this->Set(this->Get() + std::forward<U>(value));
            return *static_cast<const TDerived *>(this);
        }
 
        template <typename D, typename U>
        auto operator+=(const PropertyBase<U, D> &prop)
            -> typename std::enable_if<_AddOperationHelper<T, U>::value, TDerived &>::type
        {
            this->Set(this->Get() + prop.Get());
            return *static_cast<TDerived *>(this);
        }
 
        template <typename D, typename U>
        auto operator+=(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_AddOperationHelper<T, U>::value, const TDerived &>::type
        {
            this->Set(this->Get() + prop.Get());
            return *static_cast<const TDerived *>(this);
        }
 
        template <typename U>
        auto operator-=(U &&value)
            -> typename std::enable_if<_SubOperationHelper<T, U>::value, TDerived &>::type
        {
            this->Set(this->Get() - std::forward<U>(value));
            return *static_cast<TDerived *>(this);
        }
 
        template <typename U>
        auto operator-=(U &&value) const
            -> typename std::enable_if<_SubOperationHelper<T, U>::value, const TDerived &>::type
        {
            this->Set(this->Get() - std::forward<U>(value));
            return *static_cast<const TDerived *>(this);
        }
 
        template <typename D, typename U>
        auto operator-=(const PropertyBase<U, D> &prop)
            -> typename std::enable_if<_SubOperationHelper<T, U>::value, TDerived &>::type
        {
            this->Set(this->Get() - prop.Get());
            return *static_cast<TDerived *>(this);
        }
 
        template <typename D, typename U>
        auto operator-=(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_SubOperationHelper<T, U>::value, const TDerived &>::type
        {
            this->Set(this->Get() - prop.Get());
            return *static_cast<const TDerived *>(this);
        }
 
        template <typename U>
        auto operator*=(U &&value)
            -> typename std::enable_if<_MulOperationHelper<T, U>::value, TDerived &>::type
        {
            this->Set(this->Get() * std::forward<U>(value));
            return *static_cast<TDerived *>(this);
        }
 
        template <typename U>
        auto operator*=(U &&value) const
            -> typename std::enable_if<_MulOperationHelper<T, U>::value, const TDerived &>::type
        {
            this->Set(this->Get() * std::forward<U>(value));
            return *static_cast<const TDerived *>(this);
        }
 
        template <typename D, typename U>
        auto operator*=(const PropertyBase<U, D> &prop)
            -> typename std::enable_if<_MulOperationHelper<T, U>::value, TDerived &>::type
        {
            this->Set(this->Get() * prop.Get());
            return *static_cast<TDerived *>(this);
        }
 
        template <typename D, typename U>
        auto operator*=(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_MulOperationHelper<T, U>::value, const TDerived &>::type
        {
            this->Set(this->Get() * prop.Get());
            return *static_cast<const TDerived *>(this);
        }
 
        template <typename U>
        auto operator/=(U &&value)
            -> typename std::enable_if<_DivOperationHelper<T, U>::value, TDerived &>::type
        {
            this->Set(this->Get() / std::forward<U>(value));
            return *static_cast<TDerived *>(this);
        }
 
        template <typename U>
        auto operator/=(U &&value) const
            -> typename std::enable_if<_DivOperationHelper<T, U>::value, const TDerived &>::type
        {
            this->Set(this->Get() / std::forward<U>(value));
            return *static_cast<const TDerived *>(this);
        }
 
        template <typename D, typename U>
        auto operator/=(const PropertyBase<U, D> &prop)
            -> typename std::enable_if<_DivOperationHelper<T, U>::value, TDerived &>::type
        {
            this->Set(this->Get() / prop.Get());
            return *static_cast<TDerived *>(this);
        }
 
        template <typename D, typename U>
        auto operator/=(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_DivOperationHelper<T, U>::value, const TDerived &>::type
        {
            this->Set(this->Get() / prop.Get());
            return *static_cast<const TDerived *>(this);
        }
 
        template <typename U = T>
        auto operator++()
            -> typename std::enable_if<_AddOperationHelper<U, int>::value, TDerived &>::type
        {
            this->Set(this->Get() + 1);
            return *static_cast<TDerived *>(this);
        }
 
        template <typename U = T>
        auto operator++() const
            -> typename std::enable_if<_AddOperationHelper<U, int>::value, const TDerived &>::type
        {
            this->Set(this->Get() + 1);
            return *static_cast<const TDerived *>(this);
        }
 
        template <typename U = T>
        auto operator--()
            -> typename std::enable_if<_SubOperationHelper<U, int>::value, TDerived &>::type
        {
            this->Set(this->Get() - 1);
            return *static_cast<TDerived *>(this);
        }
 
        template <typename U = T>
        auto operator--() const
            -> typename std::enable_if<_SubOperationHelper<U, int>::value, const TDerived &>::type
        {
            this->Set(this->Get() - 1);
            return *static_cast<const TDerived *>(this);
        }
 
        template <typename U = T>
        auto operator++(int) const
            -> typename std::enable_if<_AddOperationHelper<U, int>::value, T>::type
        {
            T oldval = this->Get();
            this->Set(oldval + 1);
            return oldval;
        }
 
        template <typename U = T>
        auto operator--(int) const
            -> typename std::enable_if<_SubOperationHelper<U, int>::value, T>::type
        {
            T oldval = this->Get();
            this->Set(oldval - 1);
            return oldval;
        }
 
        template <typename U>
        auto operator&=(U &&value)
            -> typename std::enable_if<_BitAndOperationHelper<T, U>::value, TDerived &>::type
        {
            this->Set(this->Get() & std::forward<U>(value));
            return *static_cast<TDerived *>(this);
        }
 
        template <typename U>
        auto operator&=(U &&value) const
            -> typename std::enable_if<_BitAndOperationHelper<T, U>::value, const TDerived &>::type
        {
            this->Set(this->Get() & std::forward<U>(value));
            return *static_cast<const TDerived *>(this);
        }
 
        template <typename D, typename U>
        auto operator&=(const PropertyBase<U, D> &prop)
            -> typename std::enable_if<_BitAndOperationHelper<T, U>::value, TDerived &>::type
        {
            this->Set(this->Get() & prop.Get());
            return *static_cast<TDerived *>(this);
        }
 
        template <typename D, typename U>
        auto operator&=(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_BitAndOperationHelper<T, U>::value, const TDerived &>::type
        {
            this->Set(this->Get() & prop.Get());
            return *static_cast<const TDerived *>(this);
        }
 
        template <typename U>
        auto operator|=(U &&value)
            -> typename std::enable_if<_BitOrOperationHelper<T, U>::value, TDerived &>::type
        {
            this->Set(this->Get() | std::forward<U>(value));
            return *static_cast<TDerived *>(this);
        }
 
        template <typename U>
        auto operator|=(U &&value) const
            -> typename std::enable_if<_BitOrOperationHelper<T, U>::value, const TDerived &>::type
        {
            this->Set(this->Get() | std::forward<U>(value));
            return *static_cast<const TDerived *>(this);
        }
 
        template <typename D, typename U>
        auto operator|=(const PropertyBase<U, D> &prop)
            -> typename std::enable_if<_BitOrOperationHelper<T, U>::value, TDerived &>::type
        {
            this->Set(this->Get() | prop.Get());
            return *static_cast<TDerived *>(this);
        }
 
        template <typename D, typename U>
        auto operator|=(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_BitOrOperationHelper<T, U>::value, const TDerived &>::type
        {
            this->Set(this->Get() | prop.Get());
            return *static_cast<const TDerived *>(this);
        }
 
        template <typename U>
        auto operator^=(U &&value)
            -> typename std::enable_if<_BitXorOperationHelper<T, U>::value, TDerived &>::type
        {
            this->Set(this->Get() ^ std::forward<U>(value));
            return *static_cast<TDerived *>(this);
        }
 
        template <typename U>
        auto operator^=(U &&value) const
            -> typename std::enable_if<_BitXorOperationHelper<T, U>::value, const TDerived &>::type
        {
            this->Set(this->Get() ^ std::forward<U>(value));
            return *static_cast<const TDerived *>(this);
        }
 
        template <typename D, typename U>
        auto operator^=(const PropertyBase<U, D> &prop)
            -> typename std::enable_if<_BitXorOperationHelper<T, U>::value, TDerived &>::type
        {
            this->Set(this->Get() ^ prop.Get());
            return *static_cast<TDerived *>(this);
        }
 
        template <typename D, typename U>
        auto operator^=(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_BitXorOperationHelper<T, U>::value, const TDerived &>::type
        {
            this->Set(this->Get() ^ prop.Get());
            return *static_cast<const TDerived *>(this);
        }
 
        template <typename U>
        auto operator<<=(U &&value)
            -> typename std::enable_if<_ShlOperationHelper<T, U>::value, TDerived &>::type
        {
            this->Set(this->Get() << std::forward<U>(value));
            return *static_cast<TDerived *>(this);
        }
 
        template <typename U>
        auto operator<<=(U &&value) const
            -> typename std::enable_if<_ShlOperationHelper<T, U>::value, const TDerived &>::type
        {
            this->Set(this->Get() << std::forward<U>(value));
            return *static_cast<const TDerived *>(this);
        }
 
        template <typename D, typename U>
        auto operator<<=(const PropertyBase<U, D> &prop)
            -> typename std::enable_if<_ShlOperationHelper<T, U>::value, TDerived &>::type
        {
            this->Set(this->Get() << prop.Get());
            return *static_cast<TDerived *>(this);
        }
 
        template <typename D, typename U>
        auto operator<<=(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_ShlOperationHelper<T, U>::value, const TDerived &>::type
        {
            this->Set(this->Get() << prop.Get());
            return *static_cast<const TDerived *>(this);
        }
 
        template <typename U>
        auto operator>>=(U &&value)
            -> typename std::enable_if<_ShrOperationHelper<T, U>::value, TDerived &>::type
        {
            this->Set(this->Get() >> std::forward<U>(value));
            return *static_cast<TDerived *>(this);
        }
 
        template <typename U>
        auto operator>>=(U &&value) const
            -> typename std::enable_if<_ShrOperationHelper<T, U>::value, const TDerived &>::type
        {
            this->Set(this->Get() >> std::forward<U>(value));
            return *static_cast<const TDerived *>(this);
        }
 
        template <typename D, typename U>
        auto operator>>=(const PropertyBase<U, D> &prop)
            -> typename std::enable_if<_ShrOperationHelper<T, U>::value, TDerived &>::type
        {
            this->Set(this->Get() >> prop.Get());
            return *static_cast<TDerived *>(this);
        }
 
        template <typename D, typename U>
        auto operator>>=(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_ShrOperationHelper<T, U>::value, const TDerived &>::type
        {
            this->Set(this->Get() >> prop.Get());
            return *static_cast<const TDerived *>(this);
        }
 
        template <typename U = T>
        auto operator!() const
            -> typename std::enable_if<_LogicNotOperationHelper<U>::value, typename _LogicNotOperationHelper<U>::type>::type
        {
            return !this->Get();
        }
 
        template <typename U = T>
        auto operator~() const
            -> typename std::enable_if<_BitNotOperationHelper<U>::value, typename _BitNotOperationHelper<U>::type>::type
        {
            return ~this->Get();
        }
 
        template <typename U = T>
        auto operator*() const
            -> typename std::enable_if<_DerefOperationHelper<U>::value, typename _DerefOperationHelper<U>::type>::type
        {
            return *this->Get();
        }
 
        template <typename U = T>
        auto operator&() const
            -> typename std::enable_if<_AddrOperationHelper<U>::value, typename _AddrOperationHelper<U>::type>::type
        {
            return &this->Get();
        }
 
        template <typename U = T>
        auto operator+() const
            -> typename std::enable_if<_UnaryPlusOperationHelper<U>::value, typename _UnaryPlusOperationHelper<U>::type>::type
        {
            return +this->Get();
        }
 
        template <typename U = T>
        auto operator-() const
            -> typename std::enable_if<_UnaryMinusOperationHelper<U>::value, typename _UnaryMinusOperationHelper<U>::type>::type
        {
            return -this->Get();
        }
 
        template <typename U>
        auto operator+(U &&value) const
            -> typename std::enable_if<_AddOperationHelper<T, U>::value, typename _AddOperationHelper<T, U>::type>::type
        {
            return this->Get() + std::forward<U>(value);
        }
 
        template <typename D, typename U>
        auto operator+(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_AddOperationHelper<T, U>::value, typename _AddOperationHelper<T, U>::type>::type
        {
            return this->Get() + prop.Get();
        }
 
        template <typename U>
        auto operator-(U &&value) const
            -> typename std::enable_if<_SubOperationHelper<T, U>::value, typename _SubOperationHelper<T, U>::type>::type
        {
            return this->Get() - std::forward<U>(value);
        }
 
        template <typename D, typename U>
        auto operator-(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_SubOperationHelper<T, U>::value, typename _SubOperationHelper<T, U>::type>::type
        {
            return this->Get() - prop.Get();
        }
 
        template <typename U>
        auto operator*(U &&value) const
            -> typename std::enable_if<_MulOperationHelper<T, U>::value, typename _MulOperationHelper<T, U>::type>::type
        {
            return this->Get() * std::forward<U>(value);
        }
 
        template <typename D, typename U>
        auto operator*(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_MulOperationHelper<T, U>::value, typename _MulOperationHelper<T, U>::type>::type
        {
            return this->Get() * prop.Get();
        }
 
        template <typename U>
        auto operator/(U &&value) const
            -> typename std::enable_if<_DivOperationHelper<T, U>::value, typename _DivOperationHelper<T, U>::type>::type
        {
            return this->Get() / std::forward<U>(value);
        }
 
        template <typename D, typename U>
        auto operator/(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_DivOperationHelper<T, U>::value, typename _DivOperationHelper<T, U>::type>::type
        {
            return this->Get() / prop.Get();
        }
 
        template <typename U>
        auto operator%(U &&value) const
            -> typename std::enable_if<_ModOperationHelper<T, U>::value, typename _ModOperationHelper<T, U>::type>::type
        {
            return this->Get() % std::forward<U>(value);
        }
 
        template <typename D, typename U>
        auto operator%(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_ModOperationHelper<T, U>::value, typename _ModOperationHelper<T, U>::type>::type
        {
            return this->Get() % prop.Get();
        }
 
        template <typename U>
        auto operator==(U &&value) const
            -> typename std::enable_if<_EqOperationHelper<T, U>::value, typename _EqOperationHelper<T, U>::type>::type
        {
            return this->Get() == std::forward<U>(value);
        }
 
        template <typename D, typename U>
        auto operator==(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_EqOperationHelper<T, U>::value, typename _EqOperationHelper<T, U>::type>::type
        {
            return this->Get() == prop.Get();
        }
 
        template <typename U>
        auto operator!=(U &&value) const
            -> typename std::enable_if<_EqOperationHelper<T, U>::value, typename _EqOperationHelper<T, U>::type>::type
        {
            return !(*this == std::forward<U>(value));
        }
 
        template <typename D, typename U>
        auto operator!=(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_EqOperationHelper<T, U>::value, typename _EqOperationHelper<T, U>::type>::type
        {
            return !(*this == prop);
        }
 
        template <typename U>
        auto operator<(U &&value) const
            -> typename std::enable_if<_LtOperationHelper<T, U>::value, typename _LtOperationHelper<T, U>::type>::type
        {
            return this->Get() < std::forward<U>(value);
        }
 
        template <typename D, typename U>
        auto operator<(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_LtOperationHelper<T, U>::value, typename _LtOperationHelper<T, U>::type>::type
        {
            return this->Get() < prop.Get();
        }
 
        template <typename U>
        auto operator<=(U &&value) const
            -> typename std::enable_if<_LeOperationHelper<T, U>::value, typename _LeOperationHelper<T, U>::type>::type
        {
            return this->Get() <= std::forward<U>(value);
        }
 
        template <typename D, typename U>
        auto operator<=(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_LeOperationHelper<T, U>::value, typename _LeOperationHelper<T, U>::type>::type
        {
            return this->Get() <= prop.Get();
        }
 
        template <typename U>
        auto operator>(U &&value) const
            -> typename std::enable_if<_GtOperationHelper<T, U>::value, typename _GtOperationHelper<T, U>::type>::type
        {
            return this->Get() > std::forward<U>(value);
        }
 
        template <typename D, typename U>
        auto operator>(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_GtOperationHelper<T, U>::value, typename _GtOperationHelper<T, U>::type>::type
        {
            return this->Get() > prop.Get();
        }
 
        template <typename U>
        auto operator>=(U &&value) const
            -> typename std::enable_if<_GeOperationHelper<T, U>::value, typename _GeOperationHelper<T, U>::type>::type
        {
            return this->Get() >= std::forward<U>(value);
        }
 
        template <typename D, typename U>
        auto operator>=(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_GeOperationHelper<T, U>::value, typename _GeOperationHelper<T, U>::type>::type
        {
            return this->Get() >= prop.Get();
        }
 
        template <typename U>
        auto operator&(U &&value) const
            -> typename std::enable_if<_BitAndOperationHelper<T, U>::value, typename _BitAndOperationHelper<T, U>::type>::type
        {
            return this->Get() & std::forward<U>(value);
        }
 
        template <typename D, typename U>
        auto operator&(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_BitAndOperationHelper<T, U>::value, typename _BitAndOperationHelper<T, U>::type>::type
        {
            return this->Get() & prop.Get();
        }
 
        template <typename U>
        auto operator|(U &&value) const
            -> typename std::enable_if<_BitOrOperationHelper<T, U>::value, typename _BitOrOperationHelper<T, U>::type>::type
        {
            return this->Get() | std::forward<U>(value);
        }
 
        template <typename D, typename U>
        auto operator|(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_BitOrOperationHelper<T, U>::value, typename _BitOrOperationHelper<T, U>::type>::type
        {
            return this->Get() | prop.Get();
        }
 
        template <typename U>
        auto operator^(U &&value) const
            -> typename std::enable_if<_BitXorOperationHelper<T, U>::value, typename _BitXorOperationHelper<T, U>::type>::type
        {
            return this->Get() ^ std::forward<U>(value);
        }
 
        template <typename D, typename U>
        auto operator^(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_BitXorOperationHelper<T, U>::value, typename _BitXorOperationHelper<T, U>::type>::type
        {
            return this->Get() ^ prop.Get();
        }
 
        template <typename U>
        auto operator<<(U &&value) const
            -> typename std::enable_if<_ShlOperationHelper<T, U>::value, typename _ShlOperationHelper<T, U>::type>::type
        {
            return this->Get() << std::forward<U>(value);
        }
 
        template <typename D, typename U>
        auto operator<<(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_ShlOperationHelper<T, U>::value, typename _ShlOperationHelper<T, U>::type>::type
        {
            return this->Get() << prop.Get();
        }
 
        template <typename U>
        auto operator>>(U &&value) const
            -> typename std::enable_if<_ShrOperationHelper<T, U>::value, typename _ShrOperationHelper<T, U>::type>::type
        {
            return this->Get() >> std::forward<U>(value);
        }
 
        template <typename D, typename U>
        auto operator>>(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_ShrOperationHelper<T, U>::value, typename _ShrOperationHelper<T, U>::type>::type
        {
            return this->Get() >> prop.Get();
        }
 
        template <typename U>
        auto operator&&(U &&value) const
            -> typename std::enable_if<_LogicAndOperationHelper<T, U>::value, typename _LogicAndOperationHelper<T, U>::type>::type
        {
            return this->Get() && std::forward<U>(value);
        }
 
        template <typename D, typename U>
        auto operator&&(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_LogicAndOperationHelper<T, U>::value, typename _LogicAndOperationHelper<T, U>::type>::type
        {
            return this->Get() && prop.Get();
        }
 
        template <typename U>
        auto operator||(U &&value) const
            -> typename std::enable_if<_LogicOrOperationHelper<T, U>::value, typename _LogicOrOperationHelper<T, U>::type>::type
        {
            return this->Get() || std::forward<U>(value);
        }
 
        template <typename D, typename U>
        auto operator||(const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<_LogicOrOperationHelper<T, U>::value, typename _LogicOrOperationHelper<T, U>::type>::type
        {
            return this->Get() || prop.Get();
        }
 
        template <typename U>
        auto operator[](U &&value) const
            -> typename std::enable_if<
                _BracketOperationHelper<T, U>::value &&
                    !std::is_reference<typename _BracketOperationHelper<T, U>::type>::value,
                typename _BracketOperationHelper<T, U>::type>::type
        {
            return this->Get()[std::forward<U>(value)];
        }
 
        template <typename D, typename U>
        auto operator[](const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<
                _BracketOperationHelper<T, U>::value &&
                    !std::is_reference<typename _BracketOperationHelper<T, U>::type>::value,
                typename _BracketOperationHelper<T, U>::type>::type
        {
            return this->Get()[prop.Get()];
        }
 
        template <typename U>
        auto operator[](U &&value) const
            -> typename std::enable_if<
                _BracketOperationHelper<T, U>::value && std::is_pointer<T>::value,
                typename _BracketOperationHelper<T, U>::type>::type
        {
            return this->Get()[std::forward<U>(value)];
        }
 
        template <typename D, typename U>
        auto operator[](const PropertyBase<U, D> &prop) const
            -> typename std::enable_if<
                _BracketOperationHelper<T, U>::value && std::is_pointer<T>::value,
                typename _BracketOperationHelper<T, U>::type>::type
        {
            return this->Get()[prop.Get()];
        }
 
    protected:
        static constexpr std::ptrdiff_t _STATICOFFSET =
            (std::numeric_limits<std::ptrdiff_t>::max)();
 
        std::ptrdiff_t _offset{_STATICOFFSET};
 
        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 (this->IsStatic()) {
                return nullptr;
            } else {
                return const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(this)) + _offset;
            }
        }
 
    public:
        template <typename TOwner>
        static MemberPropertyInitializer<TOwner, T> Init(TOwner *owner)
        {
            return MemberPropertyInitializer<TOwner, T>(owner);
        }
 
        static StaticPropertyInitializer<T> Init()
        {
            return StaticPropertyInitializer<T>();
        }
    };
 
    /*================================================================================*/
 
    template <typename D, typename T, typename U>
    auto operator+(T &&left, const PropertyBase<U, D> &right)
        -> typename std::enable_if<!_IsProperty<T>::value && _AddOperationHelper<T, U>::value, typename _AddOperationHelper<T, U>::type>::type
    {
        return std::forward<T>(left) + right.Get();
    }
 
    template <typename D, typename T, typename U>
    auto operator-(T &&left, const PropertyBase<U, D> &right)
        -> typename std::enable_if<!_IsProperty<T>::value && _SubOperationHelper<T, U>::value, typename _SubOperationHelper<T, U>::type>::type
    {
        return std::forward<T>(left) - right.Get();
    }
 
    template <typename D, typename T, typename U>
    auto operator*(T &&left, const PropertyBase<U, D> &right)
        -> typename std::enable_if<!_IsProperty<T>::value && _MulOperationHelper<T, U>::value, typename _MulOperationHelper<T, U>::type>::type
    {
        return std::forward<T>(left) * right.Get();
    }
 
    template <typename D, typename T, typename U>
    auto operator/(T &&left, const PropertyBase<U, D> &right)
        -> typename std::enable_if<!_IsProperty<T>::value && _DivOperationHelper<T, U>::value, typename _DivOperationHelper<T, U>::type>::type
    {
        return std::forward<T>(left) / right.Get();
    }
 
    template <typename D, typename T, typename U>
    auto operator%(T &&left, const PropertyBase<U, D> &right)
        -> typename std::enable_if<!_IsProperty<T>::value && _ModOperationHelper<T, U>::value, typename _ModOperationHelper<T, U>::type>::type
    {
        return std::forward<T>(left) % right.Get();
    }
 
    template <typename D, typename T, typename U>
    auto operator==(T &&left, const PropertyBase<U, D> &right)
        -> typename std::enable_if<!_IsProperty<T>::value && _EqOperationHelper<T, U>::value, typename _EqOperationHelper<T, U>::type>::type
    {
        return std::forward<T>(left) == right.Get();
    }
 
    template <typename D, typename T, typename U>
    auto operator!=(T &&left, const PropertyBase<U, D> &right)
        -> typename std::enable_if<!_IsProperty<T>::value && _EqOperationHelper<T, U>::value, typename _EqOperationHelper<T, U>::type>::type
    {
        return !(std::forward<T>(left) == right);
    }
 
    template <typename D, typename T, typename U>
    auto operator<(T &&left, const PropertyBase<U, D> &right)
        -> typename std::enable_if<!_IsProperty<T>::value && _LtOperationHelper<T, U>::value, typename _LtOperationHelper<T, U>::type>::type
    {
        return std::forward<T>(left) < right.Get();
    }
 
    template <typename D, typename T, typename U>
    auto operator<=(T &&left, const PropertyBase<U, D> &right)
        -> typename std::enable_if<!_IsProperty<T>::value && _LeOperationHelper<T, U>::value, typename _LeOperationHelper<T, U>::type>::type
    {
        return std::forward<T>(left) <= right.Get();
    }
 
    template <typename D, typename T, typename U>
    auto operator>(T &&left, const PropertyBase<U, D> &right)
        -> typename std::enable_if<!_IsProperty<T>::value && _GtOperationHelper<T, U>::value, typename _GtOperationHelper<T, U>::type>::type
    {
        return std::forward<T>(left) > right.Get();
    }
 
    template <typename D, typename T, typename U>
    auto operator>=(T &&left, const PropertyBase<U, D> &right)
        -> typename std::enable_if<!_IsProperty<T>::value && _GeOperationHelper<T, U>::value, typename _GeOperationHelper<T, U>::type>::type
    {
        return std::forward<T>(left) >= right.Get();
    }
 
    template <typename D, typename T, typename U>
    auto operator&(T &&left, const PropertyBase<U, D> &right)
        -> typename std::enable_if<!_IsProperty<T>::value && _BitAndOperationHelper<T, U>::value, typename _BitAndOperationHelper<T, U>::type>::type
    {
        return std::forward<T>(left) & right.Get();
    }
 
    template <typename D, typename T, typename U>
    auto operator|(T &&left, const PropertyBase<U, D> &right)
        -> typename std::enable_if<!_IsProperty<T>::value && _BitOrOperationHelper<T, U>::value, typename _BitOrOperationHelper<T, U>::type>::type
    {
        return std::forward<T>(left) | right.Get();
    }
 
    template <typename D, typename T, typename U>
    auto operator^(T &&left, const PropertyBase<U, D> &right)
        -> typename std::enable_if<!_IsProperty<T>::value && _BitXorOperationHelper<T, U>::value, typename _BitXorOperationHelper<T, U>::type>::type
    {
        return std::forward<T>(left) ^ right.Get();
    }
 
    template <typename D, typename T, typename U>
    auto operator<<(T &&left, const PropertyBase<U, D> &right)
        -> typename std::enable_if<!_IsProperty<T>::value && _ShlOperationHelper<T, U>::value, typename _ShlOperationHelper<T, U>::type>::type
    {
        return std::forward<T>(left) << right.Get();
    }
 
    template <typename D, typename T, typename U>
    auto operator>>(T &&left, const PropertyBase<U, D> &right)
        -> typename std::enable_if<!_IsProperty<T>::value && _ShrOperationHelper<T, U>::value, typename _ShrOperationHelper<T, U>::type>::type
    {
        return std::forward<T>(left) >> right.Get();
    }
 
    template <typename D, typename T, typename U>
    auto operator&&(T &&left, const PropertyBase<U, D> &right)
        -> typename std::enable_if<!_IsProperty<T>::value && _LogicAndOperationHelper<T, U>::value, typename _LogicAndOperationHelper<T, U>::type>::type
    {
        return std::forward<T>(left) && right.Get();
    }
 
    template <typename D, typename T, typename U>
    auto operator||(T &&left, const PropertyBase<U, D> &right)
        -> typename std::enable_if<!_IsProperty<T>::value && _LogicOrOperationHelper<T, U>::value, typename _LogicOrOperationHelper<T, U>::type>::type
    {
        return std::forward<T>(left) || right.Get();
    }
 
    /*================================================================================*/
 
    template <typename T>
    class Property : public PropertyBase<T, Property<T>>
    {
    public:
        using TBase         = PropertyBase<T, Property<T>>;
        using TValue        = typename TBase::TValue;
        using TSetterParam  = typename TBase::TSetterParam;
        using TGetter       = T (*)(void *);
        using TSetter       = void (*)(void *, TSetterParam);
        using TStaticGetter = T (*)();
        using TStaticSetter = void (*)(TSetterParam);
 
    private:
        void *_getter;
 
        void *_setter;
 
    public:
        using TBase::operator=;
 
        template <typename TOwner>
        explicit Property(const MemberPropertyInitializer<TOwner, T> &initializer)
        {
            assert(initializer._owner != nullptr);
            assert(initializer._getter != nullptr);
            assert(initializer._setter != nullptr);
 
            this->SetOwner(initializer._owner);
            this->_getter = reinterpret_cast<void *>(initializer._getter);
            this->_setter = reinterpret_cast<void *>(initializer._setter);
        }
 
        explicit Property(const StaticPropertyInitializer<T> &initializer)
        {
            assert(initializer._getter != nullptr);
            assert(initializer._setter != nullptr);
 
            this->SetOwner(nullptr);
            this->_getter = reinterpret_cast<void *>(initializer._getter);
            this->_setter = reinterpret_cast<void *>(initializer._setter);
        }
 
        T GetterImpl() const
        {
            if (this->IsStatic()) {
                return reinterpret_cast<TStaticGetter>(this->_getter)();
            } else {
                return reinterpret_cast<TGetter>(this->_getter)(this->GetOwner());
            }
        }
 
        void SetterImpl(TSetterParam value) const
        {
            if (this->IsStatic()) {
                reinterpret_cast<TStaticSetter>(this->_setter)(value);
            } else {
                reinterpret_cast<TSetter>(this->_setter)(this->GetOwner(), value);
            }
        }
    };
 
    template <typename T>
    class ReadOnlyProperty : public PropertyBase<T, ReadOnlyProperty<T>>
    {
    public:
        using TBase         = PropertyBase<T, ReadOnlyProperty<T>>;
        using TValue        = typename TBase::TValue;
        using TSetterParam  = typename TBase::TSetterParam;
        using TGetter       = T (*)(void *);
        using TStaticGetter = T (*)();
 
    private:
        void *_getter;
 
    public:
        template <typename TOwner>
        explicit ReadOnlyProperty(const MemberPropertyInitializer<TOwner, T> &initializer)
        {
            assert(initializer._owner != nullptr);
            assert(initializer._getter != nullptr);
 
            this->SetOwner(initializer._owner);
            this->_getter = reinterpret_cast<void *>(initializer._getter);
        }
 
        explicit ReadOnlyProperty(const StaticPropertyInitializer<T> &initializer)
        {
            assert(initializer._getter != nullptr);
 
            this->SetOwner(nullptr);
            this->_getter = reinterpret_cast<void *>(initializer._getter);
        }
 
        T GetterImpl() const
        {
            if (this->IsStatic()) {
                return reinterpret_cast<TStaticGetter>(this->_getter)();
            } else {
                return reinterpret_cast<TGetter>(this->_getter)(this->GetOwner());
            }
        }
    };
 
    template <typename T>
    class WriteOnlyProperty : public PropertyBase<T, WriteOnlyProperty<T>>
    {
    public:
        using TBase         = PropertyBase<T, WriteOnlyProperty<T>>;
        using TValue        = typename TBase::TValue;
        using TSetterParam  = typename TBase::TSetterParam;
        using TSetter       = void (*)(void *, TSetterParam);
        using TStaticSetter = void (*)(TSetterParam);
 
    private:
        void *_setter;
 
    public:
        using TBase::operator=;
 
        template <typename TOwner>
        explicit WriteOnlyProperty(const MemberPropertyInitializer<TOwner, T> &initializer)
        {
            assert(initializer._owner != nullptr);
            assert(initializer._setter != nullptr);
 
            this->SetOwner(initializer._owner);
            this->_setter = reinterpret_cast<void *>(initializer._setter);
        }
 
        explicit WriteOnlyProperty(const StaticPropertyInitializer<T> &initializer)
        {
            assert(initializer._setter != nullptr);
 
            this->SetOwner(nullptr);
            this->_setter = reinterpret_cast<void *>(initializer._setter);
        }
 
        void SetterImpl(TSetterParam value) const
        {
            if (this->IsStatic()) {
                reinterpret_cast<TStaticSetter>(this->_setter)(value);
            } else {
                reinterpret_cast<TSetter>(this->_setter)(this->GetOwner(), value);
            }
        }
    };
}
 
/*================================================================================*/
 
#include <string>
 
#define _SW_DECLARE_EXTERN_PROPERTY_TEMPLATE(T)    \
    extern template class sw::Property<T>;         \
    extern template class sw::ReadOnlyProperty<T>; \
    extern template class sw::WriteOnlyProperty<T>
 
#define _SW_DEFINE_EXTERN_PROPERTY_TEMPLATE(T) \
    template class sw::Property<T>;            \
    template class sw::ReadOnlyProperty<T>;    \
    template class sw::WriteOnlyProperty<T>
 
_SW_DECLARE_EXTERN_PROPERTY_TEMPLATE(bool);
_SW_DECLARE_EXTERN_PROPERTY_TEMPLATE(float);
_SW_DECLARE_EXTERN_PROPERTY_TEMPLATE(double);
_SW_DECLARE_EXTERN_PROPERTY_TEMPLATE(int8_t);
_SW_DECLARE_EXTERN_PROPERTY_TEMPLATE(int16_t);
_SW_DECLARE_EXTERN_PROPERTY_TEMPLATE(int32_t);
_SW_DECLARE_EXTERN_PROPERTY_TEMPLATE(int64_t);
_SW_DECLARE_EXTERN_PROPERTY_TEMPLATE(uint8_t);
_SW_DECLARE_EXTERN_PROPERTY_TEMPLATE(uint16_t);
_SW_DECLARE_EXTERN_PROPERTY_TEMPLATE(uint32_t);
_SW_DECLARE_EXTERN_PROPERTY_TEMPLATE(uint64_t);
_SW_DECLARE_EXTERN_PROPERTY_TEMPLATE(std::string);
_SW_DECLARE_EXTERN_PROPERTY_TEMPLATE(std::wstring);