reflection_traits.h

#pragma once
 
#include <string>
#include <cgv/type/info/type_name.h>
#include <cgv/type/info/type_id.h>
#include <cgv/type/cond/is_enum.h>
#include <cgv/type/cond/is_abstract.h>
#include <cgv/utils/convert_string.h>
 
#include "lib_begin.h"
 
namespace cgv {
        namespace reflect {
 
class CGV_API reflection_handler;
 
enum ReflectionTraitsKind { RTK_STD_TYPE, RTK_SELF_REFLECT, RTK_EXTERNAL_SELF_REFLECT, RTK_STRING };
 
struct CGV_API abst_reflection_traits
{
        virtual ~abst_reflection_traits();
        virtual abst_reflection_traits* clone() = 0;
 
        virtual unsigned size() const = 0;
        virtual void* new_instance() const = 0;
        virtual void delete_instance(void*) const = 0;
        virtual void* new_instances(unsigned n) const = 0;
        virtual void delete_instances(void*) const = 0;
        virtual cgv::type::info::TypeId get_type_id() const = 0;
        virtual const char* get_type_name() const = 0;
 
        static const bool has_external = false;
        virtual bool has_external_implementation() const;
        virtual bool external_implementation(reflection_handler& rh, void* member_ptr);
 
        static const bool has_string = false;
        virtual bool has_string_conversions() const;
        virtual bool set_from_string(void* instance_ptr, const std::string& str_val);
        virtual void get_to_string(const void* instance_ptr, std::string& str_val);
 
 
        static const bool has_enum = false;
        virtual bool is_enum_type() const;
        virtual bool has_enum_interface() const;
        virtual unsigned get_nr_enum_items() const;
        virtual std::string get_enum_name(unsigned i) const;
        virtual int get_enum_value(unsigned i) const;
};
 
template <typename T, typename B, bool base_is_abst = cgv::type::cond::is_abstract<B>::value>
struct reflection_traits_impl : public B
{
        unsigned size() const { return sizeof(T); }
        void* new_instance() const { return new T(); }
        void delete_instance(void* instance_ptr) const { delete static_cast<T*>(instance_ptr); }
        void* new_instances(unsigned n) const { return new T[n]; }
        void delete_instances(void* instance_array) const { delete [] static_cast<T*>(instance_array); }
        cgv::type::info::TypeId get_type_id() const { return cgv::type::info::type_id<T>::get_id(); }
        const char* get_type_name() const { return cgv::type::info::type_name<T>::get_name(); }
        bool is_enum_type() const { return cgv::type::cond::is_enum<T>::value; }
};
 
template <typename T, typename B>
struct reflection_traits_impl<T,B,true> : public B
{
        unsigned size() const { return sizeof(T); }
        void* new_instance() const { return 0; }
        void delete_instance(void* instance_ptr) const { delete static_cast<T*>(instance_ptr); }
        void* new_instances(unsigned n) const { return 0; }
        void delete_instances(void* instance_array) const { delete [] static_cast<T*>(instance_array); }
        cgv::type::info::TypeId get_type_id() const { return cgv::type::info::type_id<T>::get_id(); }
        const char* get_type_name() const { return cgv::type::info::type_name<T>::get_name(); }
        bool is_enum_type() const { return cgv::type::cond::is_enum<T>::value; }
};
 
template <bool has_str, typename T, typename B>
struct reflection_traits_string_impl : public reflection_traits_impl<T,B>
{
};
 
template <typename T, typename B>
struct reflection_traits_string_impl<true,T,B> : public reflection_traits_impl<T,B>
{
        static const bool has_string = true;
 
        bool has_string_conversions() const { return true; }
        bool set_from_string(void* member_ptr, const std::string& str_val) {
                return cgv::utils::from_string(*static_cast<T*>(member_ptr), str_val);
        }
        void get_to_string(const void* member_ptr, std::string& str_val) {
                str_val = cgv::utils::to_string(*static_cast<const T*>(member_ptr));
        }
};
 
template <typename T, ReflectionTraitsKind KIND = RTK_STRING, bool has_str = true>
struct reflection_traits : public reflection_traits_string_impl<has_str, T, abst_reflection_traits>
{
        static const ReflectionTraitsKind kind = KIND;
        abst_reflection_traits* clone() { return new reflection_traits<T,KIND,has_str>(); }
};
 
 
extern CGV_API reflection_traits<bool,RTK_STD_TYPE> get_reflection_traits(const bool&);
 
        }
}
 
 
#include <cgv/config/lib_end.h>