base_generator.h

#pragma once
 
#include "base.h"
#include <cgv/type/variant.h>
#include <map>
 
#include "lib_begin.h"
 
namespace cgv {
    namespace base {
 
struct CGV_API abst_property_access
{
    bool has_changed{false};
    abst_property_access() = default;
    virtual ~abst_property_access() = default;
    virtual const char* get_type_name() const = 0;
    virtual bool set(const std::string& value_type, const void* value_ptr) = 0;
    virtual bool get(const std::string& value_type, void* value_ptr) = 0;
};
 
template <typename T>
struct standard_type_property_access : public abst_property_access
{
    T* ptr;
    standard_type_property_access(T* _ptr) : ptr(_ptr) {}
    const char* get_type_name() const override { return cgv::type::info::type_name<T>::get_name(); }
    bool set(const std::string& value_type, const void* value_ptr) override { cgv::type::get_variant(*ptr,value_type,value_ptr); has_changed = true; return true; }
    bool get(const std::string& value_type, void* value_ptr) override { cgv::type::set_variant(*ptr,value_type,value_ptr); return true; }
};
 
template <typename T>
struct emulated_property_access : public abst_property_access
{
    T* ptr;
    emulated_property_access(T* _ptr) : ptr(_ptr) {}
    const char* get_type_name() const override { return cgv::type::info::type_name<T>::get_name(); }
    bool set(const std::string& value_type, const void* value_ptr) override {
        if (value_type == get_type_name()) {
            *ptr = *((const T*) value_ptr);
            has_changed = true;
            return true;
        }
        else if (value_type == "string") {
            return has_changed = cgv::utils::from_string(*ptr, *((std::string*)value_ptr));
        }
        return false;
    }
    bool get(const std::string& value_type, void* value_ptr) override {
        if (value_type == get_type_name()) {
            *((T*) value_ptr) = *ptr;
            return true;
        }
        else if (value_type == "string") {
            *((std::string*)value_ptr) = cgv::utils::to_string(*ptr);
        }
        return false;
    }
};
 
template <typename T>
struct property_access : public emulated_property_access<T>
{
    property_access(T* _ptr) : emulated_property_access<T>(_ptr) {}
};
 
template <> struct property_access<cgv::type::int8_type>   : public standard_type_property_access<cgv::type::int8_type>   { property_access<cgv::type::int8_type>  (cgv::type::int8_type* _ptr)   : standard_type_property_access<cgv::type::int8_type>(_ptr) {}; }; 
template <> struct property_access<cgv::type::int16_type>  : public standard_type_property_access<cgv::type::int16_type>  { property_access<cgv::type::int16_type> (cgv::type::int16_type* _ptr)  : standard_type_property_access<cgv::type::int16_type>(_ptr) {}; }; 
template <> struct property_access<cgv::type::int32_type>  : public standard_type_property_access<cgv::type::int32_type>  { property_access<cgv::type::int32_type> (cgv::type::int32_type* _ptr)  : standard_type_property_access<cgv::type::int32_type>(_ptr) {}; }; 
template <> struct property_access<cgv::type::int64_type>  : public standard_type_property_access<cgv::type::int64_type>  { property_access<cgv::type::int64_type> (cgv::type::int64_type* _ptr)  : standard_type_property_access<cgv::type::int64_type>(_ptr) {}; }; 
template <> struct property_access<cgv::type::uint8_type>  : public standard_type_property_access<cgv::type::uint8_type>  { property_access<cgv::type::uint8_type> (cgv::type::uint8_type* _ptr)  : standard_type_property_access<cgv::type::uint8_type>(_ptr) {}; }; 
template <> struct property_access<cgv::type::uint16_type> : public standard_type_property_access<cgv::type::uint16_type> { property_access<cgv::type::uint16_type>(cgv::type::uint16_type* _ptr) : standard_type_property_access<cgv::type::uint16_type>(_ptr) {}; }; 
template <> struct property_access<cgv::type::uint32_type> : public standard_type_property_access<cgv::type::uint32_type> { property_access<cgv::type::uint32_type>(cgv::type::uint32_type* _ptr) : standard_type_property_access<cgv::type::uint32_type>(_ptr) {}; }; 
template <> struct property_access<cgv::type::uint64_type> : public standard_type_property_access<cgv::type::uint64_type> { property_access<cgv::type::uint64_type>(cgv::type::uint64_type* _ptr) : standard_type_property_access<cgv::type::uint64_type>(_ptr) {}; }; 
template <> struct property_access<float>       : public standard_type_property_access<float>       { property_access<float>(float* _ptr) : standard_type_property_access<float>(_ptr) {}; }; 
template <> struct property_access<double>      : public standard_type_property_access<double>      { property_access<double>(double* _ptr) : standard_type_property_access<double>(_ptr) {}; }; 
template <> struct property_access<bool>        : public standard_type_property_access<bool>        { property_access<bool>(bool* _ptr) : standard_type_property_access<bool>(_ptr) {}; }; 
template <> struct property_access<std::string> : public standard_type_property_access<std::string> { property_access<std::string>(std::string* _ptr) : standard_type_property_access<std::string>(_ptr) {}; }; 
 
class CGV_API base_generator : public base
{
protected:
    typedef std::map<std::string, abst_property_access*> map_type;
    typedef map_type::iterator iter_type;
    typedef map_type::const_iterator const_iter_type;
    map_type property_map;
public:
    ~base_generator();
    std::string get_type_name() const;
    void add_void(const std::string& name, abst_property_access* apa);
    template <typename T>
    void add(const std::string& property, T& value) { add_void(property, new property_access<T>(&value)); }
    void del(const std::string& property);
    bool changed(const std::string& property) const;
    std::string get_property_declarations();
    bool set_void(const std::string& property, const std::string& value_type, const void* value_ptr);
    bool get_void(const std::string& property, const std::string& value_type, void* value_ptr);
};
 
 
template <typename T>
bool has_property(const std::string& options, const std::string& property, T& value, bool report_error = true) {
    base_generator bg;
    bg.add(property, value);
    bg.multi_set(options, report_error);
    return bg.changed(property);
}
 
    }
}
 
 
#include <cgv/config/lib_end.h>