reflect_enum.h

#pragma once
 
#include "reflection_handler.h"
#include "lib_begin.h"
 
namespace cgv {
        namespace reflect {
 
struct CGV_API abst_enum_reflection_traits : public abst_reflection_traits
{
        static const bool has_enum = true;
        static const ReflectionTraitsKind kind = RTK_STRING;
 
        virtual std::vector<cgv::utils::token>& ref_names() = 0;
        virtual std::vector<int>& ref_values() = 0;
        virtual std::string& declarations() const = 0;
 
        void parse_declarations();
        bool has_string_conversions() const;
        bool set_from_string(void* member_ptr, const std::string& str_val);
        void get_to_string(const void* member_ptr, std::string& str_val);
 
        bool has_enum_interface() const;
        unsigned get_nr_enum_items() const;
        std::string get_enum_name(unsigned i) const;
        int get_enum_value(unsigned i) const;
};
 
template <typename T> 
struct enum_reflection_traits : public reflection_traits_impl<T, abst_enum_reflection_traits>
{
        std::vector<cgv::utils::token>& ref_names() { static std::vector<cgv::utils::token> names; return names; }
        std::vector<int>& ref_values()              { static std::vector<int> values; return values; }
        std::string& declarations() const           { static std::string decs; return decs; }
 
        enum_reflection_traits(const std::string& _declarations = "")
        { 
                if (!_declarations.empty()) {
                        declarations() = _declarations; 
                        this->parse_declarations();
                }
#ifdef REFLECT_TRAITS_WITH_DECLTYPE
                if (declarations().empty())
                        get_reflection_traits(T());
#endif
        }
        abst_reflection_traits* clone() { return new enum_reflection_traits<T>(); }
};
 
        }
}
 
#include <cgv/config/lib_end.h>