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>