reflection_handler.h

#pragma once
 
#include <vector>
#include <cgv/type/info/type_name.h>
#include <cgv/utils/convert.h>
#include <cgv/utils/token.h>
#include <cgv/type/traits/method_pointer.h>
#include <cgv/type/info/type_id.h>
 
#include "self_reflection_tag.h"
#include "reflection_traits_info.h"
 
#include "lib_begin.h"
 
namespace cgv {
    namespace reflect {
 
struct method_interface
{
    virtual void call_void(void* instance, 
                           const std::vector<abst_reflection_traits*>& param_value_traits,
                           const std::vector<const void*>& param_value_ptrs,
                           const std::vector<std::string>& param_type_names,
                           const abst_reflection_traits* result_traits = 0,
                           void* result_value_ptr = 0,
                           const std::string& result_type = "") = 0;
};
 
template <int i, int n, typename M>
struct method_parameter_traits_helper
{
    static void fill_vector(std::vector<abst_reflection_traits*>& param_value_traits)
    {
        param_value_traits.push_back(reflection_traits_info<typename cgv::type::traits::method_pointer_argument_list<M,i>::type>::traits_type().clone());
        if (i+1 < n)
            method_parameter_traits_helper<i+1,n,M>::fill_vector(param_value_traits);
    }
};
 
template <int i, typename M>
struct method_parameter_traits_helper<i,i,M>
{
    static void fill_vector(std::vector<abst_reflection_traits*>& param_value_traits)
    {
    }
};
 
template <typename M>
struct method_interface_impl;
 
class CGV_API reflection_handler
{
#ifndef REFLECT_TRAITS_WITH_DECLTYPE
    template <typename B, typename RB>
    bool reflect_base_impl(B& base_ref, const RB&);
    template <typename T, unsigned n, typename RT>
    bool reflect_const_array_impl(const std::string& member_name, T (&member_ref)[n], const RT&);
    template <typename T, typename RT>
    bool reflect_vector_impl(const std::string& member_name, std::vector<T>& member_ref, const RT&);
#endif
public:
    template <typename T>
    friend bool reflect_enum(reflection_handler& rh, const std::string& name, T& instance, const std::string& declarations);
    template <typename T>
    friend bool reflect_string(reflection_handler& rh, const std::string& name, T& instance);
    friend struct detail;
    enum GroupTraversal { GT_TERMINATE = -3, GT_SKIP = -2, GT_COMPLETE = -1 };
    static std::string group_traversal_name(GroupTraversal gt);
    enum GroupKind { GK_NO_GROUP, GK_BASE_CLASS, GK_STRUCTURE, GK_VECTOR, GK_ARRAY, GK_POINTER };
    static const char* group_kind_name(GroupKind gk);
    static bool is_array_kind(GroupKind gk);
protected:
    GroupTraversal process_structural_group_begin(GroupKind gk, const std::string& member_name, GroupTraversal gt);
    bool group_end(GroupKind gk);
    template <typename T, typename RT, typename D>
    bool self_reflect_member(const std::string& member_name, T& member_ref, const RT&, const D&, bool hard_cast)
    {
        RT rt;
        switch (process_structural_group_begin(GK_STRUCTURE, member_name, GroupTraversal(reflect_group_begin(GK_STRUCTURE, member_name, &member_ref, &rt)))) {
        case GT_TERMINATE : return false;
        case GT_COMPLETE : 
            if (hard_cast) 
                return static_cast<D&>(member_ref).D::self_reflect(*this) && group_end(GK_STRUCTURE);
            else {
                D& d = static_cast<D&>(member_ref);
                return d.self_reflect(*this) && group_end(GK_STRUCTURE);   
            }
        default: return true;
        }       
    }
    int reflect_array_begin(GroupKind group_kind, const std::string& group_name, void* group_ptr, abst_reflection_traits* rt, unsigned grp_size);
 
    struct nesting_info
    {
        GroupKind group_kind;
        const std::string* name;
        unsigned idx;
        nesting_info(GroupKind _group_kind = GK_NO_GROUP, const std::string* _name = 0, unsigned _idx = 0) : group_kind(_group_kind), name(_name), idx(_idx) {};
    };
    std::vector<nesting_info> nesting_info_stack;
 
 
    virtual int reflect_group_begin(GroupKind group_kind, const std::string& group_name, void* group_ptr, abst_reflection_traits* rt, unsigned grp_size = -1);
 
    virtual void reflect_group_end(GroupKind group_kind);
    virtual bool reflect_member_void(const std::string& member_name, void* member_ptr, abst_reflection_traits* rt) = 0;
    virtual bool reflect_method_void(const std::string& method_name, method_interface* mi_ptr,
                                     abst_reflection_traits* return_traits, const std::vector<abst_reflection_traits*>& param_value_traits) = 0;
 
public:
    virtual ~reflection_handler();
 
    virtual bool is_creative() const;
    template <typename T>
    bool reflect_member(const std::string& member_name, T& member_ref, bool hard_cast = false);
    template <typename M>
    bool reflect_method(const std::string& method_name, M m);
    template <typename B>
    bool reflect_base(B& base_ref);
    template <typename T, unsigned n>
    bool reflect_member(const std::string& member_name, T (&member_ref)[n]);
    template <typename T>
    bool reflect_member(const std::string& member_name, std::vector<T>& member_ref);
 
    template <typename T>
    bool reflect_member(const std::string& member_name, T*& member_ref);
    template <typename T, typename S>
    bool reflect_array(const std::string& member_name, T*& member_ref, S& size);
};
 
 
struct detail {
#ifndef REFLECT_TRAITS_WITH_DECLTYPE
        template <typename T, ReflectionTraitsKind K> 
        struct reflect_member_impl
        {
            template <bool has_external, typename RT>
            struct reflect_impl {
                static bool reflect(reflection_handler* rh, const std::string& member_name, T& member_ref, const RT&, bool hard_cast) {
                    RT rt;
                    return rh->reflect_member_void(member_name, &member_ref, &rt);
                }
            };
            template <typename RT>
            struct reflect_impl<true,RT> {
                static bool reflect(reflection_handler* rh, const std::string& member_name, T& member_ref, const RT&, bool hard_cast) {
                    RT rt;
                    return rh->self_reflect_member(member_name, member_ref, rt, static_cast<typename RT::external_self_reflect_type&>(member_ref), hard_cast);
                }
            };
            template <typename RT>
            static bool reflect_RT(reflection_handler* rh, const std::string& member_name, T& member_ref, const RT& rt, bool hard_cast) {
                return reflect_impl<RT::has_external,RT>::reflect(rh, member_name, member_ref, rt, hard_cast);  
            }
            static bool reflect(reflection_handler* rh, const std::string& member_name, T& member_ref, bool hard_cast) {
                return reflect_RT(rh, member_name, member_ref, get_reflection_traits(member_ref), hard_cast);
            }
        };
 
        template <typename T> struct reflect_member_impl<T,RTK_STD_TYPE> 
        {
            static bool reflect(reflection_handler* rh, const std::string& member_name, T& member_ref, bool hard_cast) {
                typename reflection_traits_info<T>::traits_type rt;
                return rh->reflect_member_void(member_name, &member_ref, &rt);
            }
        };
#else
    template <typename T, ReflectionTraitsKind K> 
    struct reflect_member_impl
    {
        static bool reflect(reflection_handler* rh, const std::string& member_name, T& member_ref, bool hard_cast) {
            typename reflection_traits_info<T>::traits_type rt;
            return rh->reflect_member_void(member_name, &member_ref, &rt);
        }
    };
 
    template <typename T> struct reflect_member_impl<T,RTK_EXTERNAL_SELF_REFLECT> 
    {
        static bool reflect(reflection_handler* rh, const std::string& member_name, T& member_ref, bool hard_cast) {
            typename reflection_traits_info<T>::traits_type rt;
            return rh->self_reflect_member(member_name, member_ref, rt, static_cast<typename reflection_traits_info<T>::traits_type::external_self_reflect_type&>(member_ref), hard_cast);
        }
    };
#endif
    template <typename T> struct reflect_member_impl<T,RTK_SELF_REFLECT> 
    {
        static bool reflect(reflection_handler* rh, const std::string& member_name, T& member_ref, bool hard_cast) {
            typename reflection_traits_info<T>::traits_type rt;
            return rh->self_reflect_member(member_name, member_ref, rt, member_ref, hard_cast);
        }
    };
 
    template <typename M, typename R>
    struct reflect_method_impl {
        static bool reflect(reflection_handler* rh, const std::string& method_name, M m)
        {
            static std::vector<abst_reflection_traits*> param_value_traits;
            static method_interface_impl<M> mi(m);
            if (param_value_traits.size() != cgv::type::traits::method_pointer<M>::nr_arguments)
                method_parameter_traits_helper<0,cgv::type::traits::method_pointer<M>::nr_arguments,M>::fill_vector(param_value_traits);
            typename reflection_traits_info<R>::traits_type rt;
            return rh->reflect_method_void(method_name, &mi, &rt, param_value_traits);
        }
    };
    template <typename M>
    struct reflect_method_impl<M,void> {
        static bool reflect(reflection_handler* rh, const std::string& method_name, M m)
        {
            static std::vector<abst_reflection_traits*> param_value_traits;
            static method_interface_impl<M> mi(m);
            if (param_value_traits.size() != cgv::type::traits::method_pointer<M>::nr_arguments)
                method_parameter_traits_helper<0,cgv::type::traits::method_pointer<M>::nr_arguments,M>::fill_vector(param_value_traits);
            return rh->reflect_method_void(method_name, &mi, 0, param_value_traits);
        }
    };
 
#ifndef REFLECT_TRAITS_WITH_DECLTYPE
    template <bool use_get, typename B>
    struct reflect_base_dispatch {         static bool reflect(reflection_handler* rh, B& base_ref) { 
        return rh->reflect_base_impl(base_ref, typename reflection_traits_info<B>::traits_type()); } };
    template <typename B>
    struct reflect_base_dispatch<true,B> { static bool reflect(reflection_handler* rh, B& base_ref) { 
        return rh->reflect_base_impl(base_ref, get_reflection_traits(base_ref)); } };
 
    template <bool use_get, typename T, unsigned n>
    struct reflect_const_array_dispatch {         static bool reflect(reflection_handler* rh, const std::string& member_name, T (&member_ref)[n]) { 
        return rh->reflect_const_array_impl(member_name, member_ref, typename reflection_traits_info<T>::traits_type()); } };
    template <typename T, unsigned n>
    struct reflect_const_array_dispatch<true,T,n> {         static bool reflect(reflection_handler* rh, const std::string& member_name, T (&member_ref)[n]) { 
        return rh->reflect_const_array_impl(member_name, member_ref, get_reflection_traits(T())); } };
 
    template <bool use_get, typename T>
    struct reflect_vector_dispatch {         static bool reflect(reflection_handler* rh, const std::string& member_name, std::vector<T>& member_ref) { 
        return rh->reflect_vector_impl(member_name, member_ref, typename reflection_traits_info<T>::traits_type()); } };
    template <typename T>
    struct reflect_vector_dispatch<true,T> {         static bool reflect(reflection_handler* rh, const std::string& member_name, std::vector<T>& member_ref) { 
        return rh->reflect_vector_impl(member_name, member_ref, get_reflection_traits(T())); } };
#endif
};
 
 
template <typename T>
bool reflection_handler::reflect_member(const std::string& member_name, T& member_ref, bool hard_cast)
{
#ifdef REFLECT_TRAITS_WITH_DECLTYPE
    return detail::reflect_member_impl<T, reflection_traits_info<T>::kind>::reflect(this, member_name, member_ref, hard_cast);
#else
    return detail::reflect_member_impl<T, reflection_traits_info<T>::kind>::reflect(this, member_name, member_ref, hard_cast);
#endif
}
 
template <typename M>
bool reflection_handler::reflect_method(const std::string& method_name, M m)
{
    return detail::reflect_method_impl<M,typename cgv::type::traits::method_pointer<M>::return_type>::reflect(this, method_name, m);
}
 
#ifdef REFLECT_TRAITS_WITH_DECLTYPE
template <typename B>
bool reflection_handler::reflect_base(B& base_ref)
{
    typename reflection_traits_info<B>::traits_type rt;
#else
template <typename B, typename RB>
bool reflection_handler::reflect_base_impl(B& base_ref, const RB&)
{
    RB rt;
#endif
    switch (process_structural_group_begin(GK_BASE_CLASS, "", GroupTraversal(reflect_group_begin(GK_BASE_CLASS, "", &base_ref, &rt)))) {
    case GT_TERMINATE : return false;
    case GT_COMPLETE : return reflect_member("", base_ref, true) && group_end(GK_BASE_CLASS);
    default: return true;
    }
}
#ifndef REFLECT_TRAITS_WITH_DECLTYPE
template <typename B>
bool reflection_handler::reflect_base(B& base_ref)
{
    return detail::reflect_base_dispatch<reflection_traits_info<B>::use_get,B>::reflect(this,base_ref);
}
#endif
 
 
 
 
 
#ifdef REFLECT_TRAITS_WITH_DECLTYPE
template <typename T, unsigned n>
bool reflection_handler::reflect_member(const std::string& member_name, T (&member_ref)[n])
{
    typename reflection_traits_info<T>::traits_type rt;
#else
template <typename T, unsigned n, typename RT>
bool reflection_handler::reflect_const_array_impl(const std::string& member_name, T (&member_ref)[n], const RT&)
{
    RT rt;
#endif
    int grp_tra = reflect_array_begin(GK_ARRAY, member_name, member_ref, &rt, n);
    if (grp_tra == GT_TERMINATE || grp_tra == GT_SKIP)
        return grp_tra == GT_SKIP;
    bool res = true;
    if (grp_tra == GT_COMPLETE) {
        for (nesting_info_stack.back().idx=0; res && nesting_info_stack.back().idx<n; ++nesting_info_stack.back().idx)
            res = reflect_member("", member_ref[nesting_info_stack.back().idx]);
        group_end(GK_ARRAY);
    }
    else {
        res = reflect_member("", member_ref[grp_tra]);
        nesting_info_stack.pop_back();
    }
    return res;
}
#ifndef REFLECT_TRAITS_WITH_DECLTYPE
template <typename T, unsigned n>
bool reflection_handler::reflect_member(const std::string& member_name, T (&member_ref)[n])
{
    return detail::reflect_const_array_dispatch<reflection_traits_info<T>::use_get,T,n>::reflect(this,member_name,member_ref);
}
#endif
 
#ifdef REFLECT_TRAITS_WITH_DECLTYPE
template <typename T>
bool reflection_handler::reflect_member(const std::string& member_name, std::vector<T>& member_ref)
{
    typename reflection_traits_info<T>::traits_type rt;
#else
template <typename T, typename RT>
bool reflection_handler::reflect_vector_impl(const std::string& member_name, std::vector<T>& member_ref, const RT&)
{
    RT rt;
#endif
    int grp_tra = reflect_array_begin(GK_VECTOR, member_name, &member_ref, &rt, (unsigned)member_ref.size());
    if (grp_tra == GT_TERMINATE || grp_tra == GT_SKIP)
        return grp_tra == GT_SKIP;
    bool res = true;
    if (grp_tra == GT_COMPLETE) {
        unsigned size = (unsigned)member_ref.size();
        res = reflect_member("size", size);
        if (member_ref.size() != size)
            member_ref.resize(size);
        for (nesting_info_stack.back().idx=0; res && nesting_info_stack.back().idx<size; ++nesting_info_stack.back().idx)
            res = reflect_member("", member_ref[nesting_info_stack.back().idx]);
        group_end(GK_VECTOR);
    }
    else {
        res = reflect_member("", member_ref[grp_tra]);
        nesting_info_stack.pop_back();
    }
    return res;
}
#ifndef REFLECT_TRAITS_WITH_DECLTYPE
template <typename T>
bool reflection_handler::reflect_member(const std::string& member_name, std::vector<T>& member_ref)
{
    return detail::reflect_vector_dispatch<reflection_traits_info<T>::use_get,T>::reflect(this, member_name, member_ref);
}
#endif
 
template <typename T>
bool reflection_handler::reflect_member(const std::string& member_name, T*& member_ref)
{
    typename reflection_traits_info<T>::traits_type rt;
    GroupTraversal gt = reflect_group_begin(GK_POINTER, member_name, &member_ref, &rt);
    switch (gt) {
    case GT_TERMINATE : return false;
    case GT_SKIP : return true;
    case GT_COMPLETE : break;
    default: 
        std::cerr << "group traversal " << group_traversal_name(gt) << " not allowed on pointer group " << member_name << "!" << std::endl;
        return false;
    }
    nesting_info_stack.push_back(nesting_info(GK_POINTER, &member_name));
    unsigned pointer_type = (member_ref == 0 ? 0 : 1);
    unsigned pointer_type_tmp = pointer_type;
    bool res = reflect_member("pointer_type", pointer_type_tmp);
    if (res) {
        if (pointer_type_tmp != pointer_type) {
            if (pointer_type != 0)
                delete member_ref;
            if (pointer_type_tmp == 0)
                member_ref = 0;
            else
                member_ref = new T();
        }
        if (pointer_type_tmp != 0)
            res = reflect_member(*member_ref);
    }
    group_end(GK_POINTER);
    return res;
}
template <typename T, typename S>
bool reflection_handler::reflect_array(const std::string& member_name, T*& member_ref, S& size)
{
    typename reflection_traits_info<T>::traits_type rt;
    int grp_tra = reflect_array_begin(GK_ARRAY, member_name, member_ref, &rt, size);
    if (grp_tra == GT_TERMINATE || grp_tra == GT_SKIP)
        return grp_tra == GT_SKIP;
    bool res = true;
    if (grp_tra == GT_COMPLETE) {
        unsigned tmp_size = size;
        res = reflect_member("size", tmp_size);
        if (size != tmp_size) {
            T* tmp = member_ref;
            member_ref = new T[tmp_size];
            if (tmp) {
                for (unsigned i=0; i<tmp_size && i < size; ++i)
                    member_ref[i] = tmp[i];
                delete [] tmp;
            }
            size = tmp_size;
        }
        for (nesting_info_stack.back().idx=0; res && nesting_info_stack.back().idx<size; ++nesting_info_stack.back().idx)
            res = reflect_member("", member_ref[nesting_info_stack.back().idx]);
        group_end(GK_ARRAY);
    }
    else {
        res = reflect_member("", member_ref[grp_tra]);
        nesting_info_stack.pop_back();
    }
    return res;
}
 
    }
}
 
#include <cgv/config/lib_end.h>