class type

class RTTR_API type

对github项目rttr（C++反射库）解析，链接：https://github.com/rttrorg/rttr

class RTTR_API type
{
	...
 	friend class variant;
    template<typename Target_Type, typename Source_Type>
    friend Target_Type rttr_cast(Source_Type object) RTTR_NOEXCEPT;

    friend class instance;
    friend class detail::type_register;
    friend class detail::type_register_private;
    friend class visitor;
    friend struct detail::class_data;

    friend type detail::create_type(detail::type_data*) RTTR_NOEXCEPT;

    template<typename T>
    friend std::unique_ptr<detail::type_data> detail::make_type_data();

    template<typename T, typename Tp, typename Converter>
    friend struct detail::variant_data_base_policy;

    friend RTTR_API bool detail::compare_types_less_than(const void*, const void*, const type&, int&);
    friend RTTR_API bool detail::compare_types_equal(const void*, const void*, const type&, bool&);

private:
    detail::type_data* m_type_data;
}

type_data

struct RTTR_LOCAL type_data
{
    type_data* raw_type_data;
    type_data* wrapped_type;
    type_data* array_raw_type;

    std::string name;
    string_view type_name;

    std::size_t get_sizeof;
    std::size_t get_pointer_dimension;

    impl::create_variant_func create_variant;
    impl::get_base_types_func get_base_types; // FIXME: this info should not be stored, its just temporarily,
                                              // thats why we store it as function pointer

    enumeration_wrapper_base*  enum_wrapper;
    impl::get_metadata_func    get_metadata;
    impl::create_wrapper_func  create_wrapper;
    impl::visit_type_func      visit_type;

    bool is_valid;
    RTTR_FORCE_INLINE bool type_trait_value(type_trait_infos type_trait) const RTTR_NOEXCEPT { return m_type_traits.test(static_cast<std::size_t>(type_trait)); }


    type_traits m_type_traits;
    class_data  m_class_data;

};

• raw_type_data、wrapped_type、array_raw_type -> 自身type_data类型指针
• string_view type_name -> 只是暂存字符串地址
• create_variant_func

using create_variant_func  = decltype(&create_invalid_variant_policy::create_variant);

struct RTTR_LOCAL create_invalid_variant_policy
{
    static variant create_variant(const argument& data)
    {
        return variant();
    }
};

create_variant_func = variant*

• get_base_types_func

using get_base_types_func  = decltype(&base_classes<int>::get_types);

template<typename T, typename Enable = void>
struct RTTR_LOCAL base_classes
{
    static RTTR_INLINE info_container get_types()
    {
        info_container result;
        return result;
    }
};

using info_container = std::vector<detail::base_class_info>;

struct base_class_info
{
    base_class_info(type t, void*(*rttr_cast_func)(void*))
    :   m_base_type(t), m_rttr_cast_func(rttr_cast_func)
    {}
    type            m_base_type;
    void*           (*m_rttr_cast_func)(void*);
};

get_base_types_func = std::vector<detail::base_class_info >*

每个base_class_info包含type类型的成员变量和void (*)(void )类型的函数

• enumeration_wrapper_base

class RTTR_API enumeration_wrapper_base
{
	...
private:
	type m_declaring_type;
}

enumeration_wrapper_base中的所有函数调用返回都是默认构造。

• get_metadata_func

using get_metadata_func    = std::vector<metadata>&(*)(void);

std::vector & 作为返回值，没有形参

class RTTR_API metadata
{
    public:
        metadata() { }
        metadata(variant key, variant value) : m_key(std::move(key)), m_value(std::move(value)) { }
        metadata(const metadata& other) : m_key(other.m_key), m_value(other.m_value) {}
        metadata(metadata&& other) : m_key(std::move(other.m_key)), m_value(std::move(other.m_value)) {}
        metadata& operator=(const metadata& other) { m_key = other.m_key; m_value = other.m_value; return *this; }

        variant get_key() const      { return m_key; }
        variant get_value() const    { return m_value; }

        struct order_by_key
        {
            RTTR_INLINE bool operator () ( const metadata& _left, const metadata& _right )  const
            {
                return _left.m_key < _right.m_key;
            }
            RTTR_INLINE bool operator () ( const variant& _left, const metadata& _right ) const
            {
                return _left < _right.m_key;
            }
            RTTR_INLINE bool operator () ( const metadata& _left, const variant& _right ) const
            {
                return _left.m_key < _right;
            }
        };

    private:
        variant m_key;
        variant m_value;
};

两个variant成员变量，从代码上看m_key和m_value无实际联系。

• create_wrapper_func

using create_wrapper_func  = void(*)(const argument& arg, variant& var);

• visit_type_func

using visit_type_func      = void(*)(type_of_visit, visitor&, const type&);

• type_traits

using type_traits = std::bitset<static_cast<std::size_t>(type_trait_infos::TYPE_TRAIT_COUNT)>;

enum class type_trait_infos : std::size_t
{
    is_class = 0,
    is_enum,
    is_array,
    is_pointer,
    is_arithmetic,
    is_function_pointer,
    is_member_object_pointer,
    is_member_function_pointer,
    is_associative_container,
    is_sequential_container,
    is_template_instantiation,

    TYPE_TRAIT_COUNT
};

type_traits = std::bitset<11>, 位图中包含了所有type_traits_infos中的enum值

• class_data

struct RTTR_LOCAL class_data
{
    class_data(get_derived_info_func func, std::vector<type> nested_types)
    :   m_derived_info_func(func),
        m_nested_types(nested_types),
        m_dtor(create_invalid_item<destructor>())
    {}

    get_derived_info_func       m_derived_info_func;
    std::vector<type>           m_base_types;
    std::vector<type>           m_derived_types;
    std::vector<rttr_cast_func> m_conversion_list;
    std::vector<property>       m_properties;
    std::vector<method>         m_methods;
    std::vector<constructor>    m_ctors;
    std::vector<type>           m_nested_types;
    destructor                  m_dtor;
};

using get_derived_info_func = derived_info(*)(void*);

struct derived_info
{
    void* m_ptr;    //!< A void pointer, which contains the address to an arbitrary instance.
    type m_type;    //!< The corresponding typ object to the \ref m_ptr
};

class RTTR_API destructor
{
    public:
		...

    private:
        destructor(const detail::destructor_wrapper_base* wrapper) RTTR_NOEXCEPT;

        template<typename T>
        friend T detail::create_item(const detail::class_item_to_wrapper_t<T>* wrapper);
        template<typename T>
        friend T detail::create_invalid_item();

    private:
        const detail::destructor_wrapper_base* m_wrapper;
};

class RTTR_API destructor_wrapper_base
{
    public:
        destructor_wrapper_base() RTTR_NOEXCEPT;
        virtual ~destructor_wrapper_base();

        virtual bool is_valid() const RTTR_NOEXCEPT;
        virtual type get_declaring_type() const RTTR_NOEXCEPT;
        virtual type get_destructed_type() const RTTR_NOEXCEPT;
        virtual bool invoke(variant& obj) const RTTR_NOEXCEPT;
};

m_derived_info_func是个函数，这个函数结果是derived_info；destructor_wrapper_base中使用了都是virtual函数，作为基类只是提供函数，派生类中来重写对相关自身派生类成员变量做出对应的个性化处理。目前并不知道具体作用，分析全局时慢慢解析其具体作用。

type

看完了type_data类，只知道具体时存放相关类型的数据信息，但是具体存什么并不知道，切莫着急，回归class type中，只是对type_data* m_type_data来做处理。

• RTTR_INLINE type(const type& other) RTTR_NOEXCEPT;

RTTR_INLINE type::type(detail::type_data* data) RTTR_NOEXCEPT
:  m_type_data(data)
{
}

由此可见，上层主动new出type_data空间，相关数据由type类来管理。

• RTTR_INLINE type_id get_id() const RTTR_NOEXCEPT;

RTTR_INLINE type::type_id type::get_id() const RTTR_NOEXCEPT
{
    return reinterpret_cast<type::type_id>(m_type_data);
}

将m_type_data指针类型的数据强制转换为int64的类型的数据。

*总结：type主要是对type_data m_type_data成员变量做处理，获取m_type_data类中的相关属性以及其他友元类的相关处理。**具体友元类相关处理意义得从上层调用得知。本章介绍到此为止。