ReflectAPI.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "AstUtil/StringView.hpp"
#include "AstUtil/Dimension.hpp"
#include <string>
 
AST_NAMESPACE_BEGIN
 
template<typename T>
struct property_trait
{
    using output_type = T;
    using input_type = T;
};
 
template<>
struct property_trait<std::string>
{
    using output_type = std::string;
    using input_type = StringView;
};
 
template<>
struct property_trait<TimePoint>
{
    using output_type = TimePoint;
    using input_type = TimePoint;
};
 
 
 
typedef errc_t (*FPropertyGet)(const void* obj, void* value);              
typedef errc_t (*FPropertySet)(void* obj, void const* value);        
 
 
class Property;
 
AST_UTIL_CAPI Property* _aNewPropertyBool(FPropertyGet getter, FPropertySet setter);
 
 
AST_UTIL_CAPI Property* _aNewPropertyInt(FPropertyGet getter, FPropertySet setter);
 
 
AST_UTIL_CAPI Property* _aNewPropertyDouble(FPropertyGet getter, FPropertySet setter);
 
 
AST_UTIL_CAPI Property* _aNewPropertyString(FPropertyGet getter, FPropertySet setter);
 
 
AST_UTIL_CAPI Property* _aNewPropertyQuantity(FPropertyGet getter, FPropertySet setter, Dimension dimension);
 
 
 
template<typename T>
A_ALWAYS_INLINE Property* _aNewProperty(FPropertyGet getter, FPropertySet setter);
 
 
 
template<>
A_ALWAYS_INLINE Property* _aNewProperty<bool>(FPropertyGet getter, FPropertySet setter)
{
    return _aNewPropertyBool(getter, setter);
}
 
template<>
A_ALWAYS_INLINE Property* _aNewProperty<int>(FPropertyGet getter, FPropertySet setter)
{
    return _aNewPropertyInt(getter, setter);
}
 
template<>
A_ALWAYS_INLINE Property* _aNewProperty<double>(FPropertyGet getter, FPropertySet setter)
{
    return _aNewPropertyDouble(getter, setter);
}
 
 
template<>
A_ALWAYS_INLINE Property* _aNewProperty<std::string>(FPropertyGet getter, FPropertySet setter)
{
    return _aNewPropertyString(getter, setter);
}
 
 
template<typename T, bool T::* Member>
A_ALWAYS_INLINE Property* aNewPropertyBoolMem()
{
    return _aNewPropertyBool(
        [](const void* obj, void* value) -> errc_t
        {
            *((bool*)value) = ((T*)obj)->*Member;
            return 0;
        },
        [](void* obj, const void* value) -> errc_t
        {
            ((T*)obj)->*Member = *((bool*)value);
            return 0;
        }
    );
}
 
 
 
template<typename T, bool T::* Member>
A_ALWAYS_INLINE Property* aNewPropertyBool()
{
    return aNewPropertyBoolMem<T, Member>();
}
 
 
template<typename T, int T::* Member>
A_ALWAYS_INLINE Property* aNewPropertyIntMem()
{
    return _aNewPropertyInt(
        [](const void* obj, void* value) -> errc_t
        {
            *((int*)value) = ((T*)obj)->*Member;
            return 0;
        },
        [](void* obj, const void* value) -> errc_t
        {
            ((T*)obj)->*Member = *((int*)value);
            return 0;
        }
    );
}
 
 
 
template<typename T, int T::* Member>
A_ALWAYS_INLINE Property* aNewPropertyInt()
{
    return aNewPropertyIntMem<T, Member>();
}
 
 
template<typename T, double T::* Member>
A_ALWAYS_INLINE Property* aNewPropertyDoubleMem()
{
    return _aNewPropertyDouble(
        [](const void* obj, void* value) -> errc_t
        {
            *((double*)value) = ((T*)obj)->*Member;
            return 0;
        },
        [](void* obj, const void* value) -> errc_t
        {
            ((T*)obj)->*Member = *((double*)value);
            return 0;
        }
    );
}
 
 
 
template<typename T, double T::* Member>
A_ALWAYS_INLINE Property* aNewPropertyDouble()
{
    return aNewPropertyDoubleMem<T, Member>();
}
 
 
 
template<typename T, double T::* Member>
A_ALWAYS_INLINE Property* aNewPropertyQuantityMem(Dimension dimension)
{
    return _aNewPropertyDouble(
        [](const void* obj, void* value) -> errc_t
        {
            *((double*)value) = ((T*)obj)->*Member;
            return 0;
        },
        [](void* obj, const void* value) -> errc_t
        {
            ((T*)obj)->*Member = *((double*)value);
            return 0;
        },
        dimension
    );
}
 
 
 
template<typename T, double T::* Member>
A_ALWAYS_INLINE Property* aNewPropertyQuantity(Dimension dimension)
{
    return aNewPropertyQuantityMem<T, Member>(dimension);
}
 
template<typename T, std::string T::* Member>
A_ALWAYS_INLINE Property* aNewPropertyStringMem()
{
    return _aNewPropertyString(
        [](const void* obj, void* value) -> errc_t
        {
            *((std::string*)value) = ((T*)obj)->*Member;
            return 0;
        },
        [](void* obj, const void* value) -> errc_t
        {
            ((T*)obj)->*Member = std::string(*((typename property_trait<std::string>::input_type*)value));
            return 0;
        }
    );
}
 
 
template<typename T, std::string T::* Member>
A_ALWAYS_INLINE Property* aNewPropertyString()
{
    return aNewPropertyStringMem<T, Member>();
}
 
 
 
template<typename T, bool(T::* Getter) () const>
A_ALWAYS_INLINE Property* aNewPropertyBool()
{
    return _aNewPropertyBool(
        [](const void* obj, void* value) -> errc_t
        {
            *((bool*)value) = (((T*)obj)->*Getter)();
            return 0;
        },
        nullptr
    );
}
 
 
template<typename T, int(T::* Getter) () const>
A_ALWAYS_INLINE Property* aNewPropertyInt()
{
    return _aNewPropertyInt(
        [](const void* obj, void* value) -> errc_t
        {
            *((int*)value) = (((T*)obj)->*Getter)();
            return 0;
        },
        nullptr
    );
}
 
 
 
template<typename T, double (T::* Getter) () const>
A_ALWAYS_INLINE Property* aNewPropertyDouble()
{
    static_assert(Getter!=nullptr, "invalid getter");
    
    return _aNewPropertyDouble(
        [](const void* obj, void* value) -> errc_t
        {
             *((double*)value) = (((T*)obj)->*Getter)();
             return 0;
        }, 
        nullptr
    );
}
 
 
template<typename T, double (T::* Getter) () const>
A_ALWAYS_INLINE Property* aNewPropertyQuantity(Dimension dimension)
{
    static_assert(Getter!=nullptr, "invalid getter");
 
    return _aNewPropertyQuantity(
        [](const void* obj, void* value) -> errc_t
        {
             *((double*)value) = (((T*)obj)->*Getter)();
             return 0;
        }, 
        nullptr,
        dimension
    );
}
 
 
template<typename T, std::string(T::*Getter)() const>
A_ALWAYS_INLINE Property* aNewPropertyString()
{
    return _aNewPropertyString(
        [](const void* obj, void* value) -> errc_t
        {
            *((std::string*)value) = (((T*)obj)->*Getter)();
            return 0;
        },
        nullptr
    );
}
 
 
template<typename T, bool (T::* Getter) () const, void (T::* Setter)(bool)>
A_ALWAYS_INLINE Property* aNewPropertyBool()
{
    return _aNewPropertyBool(
        [](const void* obj, void* value) -> errc_t
        {
            *((bool*)value) = (((T*)obj)->*Getter)();
            return 0;
        },
        [](void* obj, const void* value) -> errc_t
        {
            static_assert(Setter!=nullptr, "invalid setter");
            (((T*)obj)->*Setter)(*((bool*)value));
            return 0;
        }
    );
}
 
 
 
template<typename T, int(T::* Getter) () const, void (T::* Setter)(int)>
A_ALWAYS_INLINE Property* aNewPropertyInt()
{
    static_assert(Getter!=nullptr, "invalid getter");
    static_assert(Setter!=nullptr, "invalid setter");
 
    return _aNewPropertyInt(
        [](const void* obj, void* value) -> errc_t
    {
        *((int*)value) = (((T*)obj)->*Getter)();
        return 0;
    },
        [](void* obj, const void* value) -> errc_t
    {
        (((T*)obj)->*Setter)(*((int*)value));
        return 0;
    }
    );
}
 
 
template<typename T, double (T::* Getter) () const, void (T::* Setter)(double)>
A_ALWAYS_INLINE Property* aNewPropertyDouble()
{
    static_assert(Getter!=nullptr, "invalid getter");
    static_assert(Setter!=nullptr, "invalid setter");
 
    return _aNewPropertyDouble(
        [](const void* obj, void* value) -> errc_t
    {
        *((double*)value) = (((T*)obj)->*Getter)();
        return 0;
    },
        [](void* obj, const void* value) -> errc_t
    {
        (((T*)obj)->*Setter)(*((double*)value));
        return 0;
    }
    );
}
 
template<typename T, double (T::* Getter) () const, void (T::* Setter)(double)>
A_ALWAYS_INLINE Property* aNewPropertyQuantity(Dimension dimension)
{
    static_assert(Getter!=nullptr, "invalid getter");
    static_assert(Setter!=nullptr, "invalid setter");
 
    return _aNewPropertyQuantity(
        [](const void* obj, void* value) -> errc_t
    {
        *((double*)value) = (((T*)obj)->*Getter)();
        return 0;
    },
        [](void* obj, const void* value) -> errc_t
    {
        (((T*)obj)->*Setter)(*((double*)value));
        return 0;
    },
        dimension
    );
}
 
 
template<typename T, const std::string& (T::* Getter) () const, void (T::* Setter)(StringView)>
A_ALWAYS_INLINE Property* aNewPropertyString()
{
    static_assert(Getter!=nullptr, "invalid getter");
    static_assert(Setter!=nullptr, "invalid setter");
 
    return _aNewPropertyString(
        [](const void* obj, void* value) -> errc_t
    {
        *((std::string*)value) = (((T*)obj)->*Getter)();
        return 0;
    },
        [](void* obj, const void* value) -> errc_t
    {
        (((T*)obj)->*Setter)(*((typename property_trait<std::string>::input_type*)value));
        return 0;
    }
    );
}
 
 
 
template<typename T, bool (T::* Getter) () const, errc_t (T::* Setter)(bool)>
A_ALWAYS_INLINE Property* aNewPropertyBool()
{
    return _aNewPropertyBool(
        [](const void* obj, void* value) -> errc_t
        {
            *((bool*)value) = (((T*)obj)->*Getter)();
            return 0;
        },
        [](void* obj, const void* value) -> errc_t
        {
            static_assert(Setter!=nullptr, "invalid setter");
            return (((T*)obj)->*Setter)(*((bool*)value));
        }
    );
}
 
 
 
template<typename T, int (T::* Getter) () const, errc_t (T::* Setter)(int)>
A_ALWAYS_INLINE Property* aNewPropertyInt()
{
    static_assert(Getter!=nullptr, "invalid getter");
    static_assert(Setter!=nullptr, "invalid setter");
 
    return _aNewPropertyInt(
        [](const void* obj, void* value) -> errc_t
    {
        *((int*)value) = (((T*)obj)->*Getter)();
        return 0;
    },
        [](void* obj, const void* value) -> errc_t
    {
        return (((T*)obj)->*Setter)(*((int*)value));
    }
    );
}
 
 
template<typename T, double (T::* Getter) () const, errc_t (T::* Setter)(double)>
A_ALWAYS_INLINE Property* aNewPropertyDouble()
{
    static_assert(Getter!=nullptr, "invalid getter");
    static_assert(Setter!=nullptr, "invalid setter");
 
    return _aNewPropertyDouble(
        [](const void* obj, void* value) -> errc_t
    {
        *((double*)value) = (((T*)obj)->*Getter)();
        return 0;
    },
        [](void* obj, const void* value) -> errc_t
    {
        return (((T*)obj)->*Setter)(*((double*)value));
    }
    );
}
 
 
template<typename T, double (T::* Getter) () const, errc_t (T::* Setter)(double)>
A_ALWAYS_INLINE Property* aNewPropertyQuantity(Dimension dimension)
{
    static_assert(Getter!=nullptr, "invalid getter");
    static_assert(Setter!=nullptr, "invalid setter");
 
    return _aNewPropertyQuantity(
        [](const void* obj, void* value) -> errc_t
    {
        *((double*)value) = (((T*)obj)->*Getter)();
        return 0;
    },
        [](void* obj, const void* value) -> errc_t
    {
        return (((T*)obj)->*Setter)(*((double*)value));
    },
        dimension
    );
}
 
template<typename T, const std::string& (T::* Getter) () const, errc_t (T::* Setter)(StringView)>
A_ALWAYS_INLINE Property* aNewPropertyString()
{
    static_assert(Getter!=nullptr, "invalid getter");
    static_assert(Setter!=nullptr, "invalid setter");
 
    return _aNewPropertyString(
        [](const void* obj, void* value) -> errc_t
    {
        *((std::string*)value) = (((T*)obj)->*Getter)();
        return 0;
    },
        [](void* obj, const void* value) -> errc_t
    {
        return (((T*)obj)->*Setter)(*((typename property_trait<std::string>::input_type*)value));
    }
    );
}
 
AST_NAMESPACE_END