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>