prop.h

Go to the documentation of this file.

 
#ifndef PROP_H_
#define PROP_H_
 
#include <any>
#include <variant>
 
#include "cube.h"
 
namespace prop
{
 
typedef std::variant<int, float, bvec, ivec, vec, std::string> PropertyValue;
 
typedef std::function<void(std::any argument)> OnChangeCallback;
 
enum class PropertyType
{
    NoType = -1,
 
    Int,
    Float,
    Color,
    IntVec,
    FloatVec,
    String,
 
    Count
};
 
class PropertyMeta
{
private:
    std::string name;
    PropertyType type;
    PropertyValue min, def, max;
    OnChangeCallback on_change;
 
public:
    PropertyType get_type() const;
    PropertyValue get_min() const;
    PropertyValue get_def() const;
    PropertyValue get_max() const;
    std::string get_name() const;
 
    void changed(std::any argument) const;
 
    template<class T> PropertyMeta(std::string _name, PropertyType _type, T _min, T _def, T _max,
                                   OnChangeCallback _on_change = nullptr) :
        name(_name), type(_type), min(_min), def(_def), max(_max), on_change(_on_change) {}
    template<class T> PropertyMeta(std::string _name, PropertyType _type, T _def,
                                   OnChangeCallback _on_change = nullptr) :
        name(_name), type(_type), def(_def), on_change(_on_change) {}
 
    PropertyMeta(const PropertyMeta&) = delete;
};
 
template<typename PropertyMetaT = PropertyMeta>
class Property
{
private:
    PropertyValue value;
    const PropertyMetaT& meta;
 
    bool set_check_type(PropertyType type) const;
    void set_clamped(PropertyValue value);
 
public:
    const PropertyValue& get_value() const;
    int get_int() const;
    float get_float() const;
    const bvec& get_color() const;
    const ivec& get_ivec() const;
    const vec& get_fvec() const;
    const std::string& get_string() const;
    size_t get_size() const;
    std::string get_name() const;
    PropertyType get_type() const;
 
    std::string to_string() const;
 
    void copy(const Property& prop);
 
    void set(PropertyValue value, std::any on_change_argument = std::any());
    void set_no_cb(PropertyValue value);
 
    void reset();
 
    void cmd_result() const;
    void cmd_result_min() const;
    void cmd_result_def() const;
    void cmd_result_max() const;
 
    virtual void pack(std::vector<uint8_t>& buf) const;
    virtual size_t unpack(const uint8_t* buf, size_t len);
 
    Property(const PropertyMetaT& _meta);
    virtual ~Property() = default;
};
 
 
 
// Implementation //
 
 
 
template<typename PropertyMetaT>
int Property<PropertyMetaT>::get_int() const
{
    return std::get<int>(value);
}
 
template<typename PropertyMetaT>
float Property<PropertyMetaT>::get_float() const
{
    return std::get<float>(value);
}
 
template<typename PropertyMetaT>
const bvec& Property<PropertyMetaT>::get_color() const
{
    return std::get<bvec>(value);
}
 
template<typename PropertyMetaT>
const ivec& Property<PropertyMetaT>::get_ivec() const
{
    return std::get<ivec>(value);
}
 
template<typename PropertyMetaT>
const vec& Property<PropertyMetaT>::get_fvec() const
{
    return std::get<vec>(value);
}
 
template<typename PropertyMetaT>
const std::string& Property<PropertyMetaT>::get_string() const
{
    return std::get<std::string>(value);
}
 
template<typename PropertyMetaT>
size_t Property<PropertyMetaT>::get_size() const
{
    switch(get_type())
    {
    case PropertyType::Int:
        return sizeof(int);
    case PropertyType::Float:
        return sizeof(float);
    case PropertyType::Color:
        return sizeof(bvec);
    case PropertyType::IntVec:
        return sizeof(ivec);
    case PropertyType::FloatVec:
        return sizeof(vec);
    case PropertyType::String:
        return get_string().size();
    default:
        return 0;
    }
}
 
template<typename PropertyMetaT>
std::string Property<PropertyMetaT>::to_string() const
{
    switch(get_type())
    {
    case PropertyType::Int:
        return std::to_string(get_int());
 
    case PropertyType::Float:
        return std::to_string(get_float());
 
    case PropertyType::Color:
        return std::to_string(get_color().r) + " " + std::to_string(get_color().g) + " " + std::to_string(get_color().b);
 
    case PropertyType::IntVec:
        return std::to_string(get_ivec().x) + " " + std::to_string(get_ivec().y) + " " + std::to_string(get_ivec().z);
 
    case PropertyType::FloatVec:
        return std::to_string(get_fvec().x) + " " + std::to_string(get_fvec().y) + " " + std::to_string(get_fvec().z);
 
    case PropertyType::String:
        return get_string();
 
    default:
        return "";
    }
}
 
template<typename PropertyMetaT>
bool Property<PropertyMetaT>::set_check_type(PropertyType type) const
{
    // typename used in debug printout below
    //static constexpr std::string_view typenames[] =
    //{
    //    "int", "float", "color", "int vector", "float vector", "string"
    //};
 
    if(get_type() != type)
    {
        // conoutf("Error: %s, incorrect property assignment type: got %s, expected %s",
        //         meta.get_name().c_str(), std::string(typenames[static_cast<size_t>(type)]).c_str(),
        //         std::string(typenames[static_cast<size_t>(get_type())]).c_str());
 
        return false;
    }
 
    return true;
}
 
template<typename PropertyMetaT>
std::string Property<PropertyMetaT>::get_name() const
{
    return meta.get_name();
}
 
template<typename PropertyMetaT>
PropertyType Property<PropertyMetaT>::get_type() const
{
    return meta.get_type();
}
 
template<typename PropertyMetaT>
void Property<PropertyMetaT>::copy(const Property& prop)
{
    set_no_cb(prop.value);
}
 
template<typename PropertyMetaT>
void Property<PropertyMetaT>::set_clamped(PropertyValue value)
{
    switch(get_type())
    {
        case PropertyType::Int:
        {
            int v = std::get<int>(value);
            this->value = std::clamp(v, std::get<int>(meta.get_min()), std::get<int>(meta.get_max()));
            break;
        }
 
        case PropertyType::Float:
        {
            float v = std::get<float>(value);
            this->value = std::clamp(v, std::get<float>(meta.get_min()), std::get<float>(meta.get_max()));
            break;
        }
 
        case PropertyType::IntVec:
        {
            ivec v = std::get<ivec>(value);
            this->value = ivec(v).min(std::get<ivec>(meta.get_max()))
                                 .max(std::get<ivec>(meta.get_min()));
            break;
        }
 
        case PropertyType::FloatVec:
        {
            vec v = std::get<vec>(value);
            this->value = vec(v).min(std::get<vec>(meta.get_max()))
                                .max(std::get<vec>(meta.get_min()));
            break;
        }
 
        default:
            this->value = value;
            break;
    }
}
 
template<typename PropertyMetaT>
void Property<PropertyMetaT>::set(PropertyValue value, std::any on_change_arg)
{
    if(set_check_type(static_cast<PropertyType>(value.index())))
    {
        set_clamped(value);
        meta.changed(on_change_arg);
    }
}
 
template<typename PropertyMetaT>
void Property<PropertyMetaT>::set_no_cb(PropertyValue value)
{
    if(set_check_type(static_cast<PropertyType>(value.index())))
    {
        set_clamped(value);
    }
}
 
template<typename PropertyMetaT>
void Property<PropertyMetaT>::reset()
{
    this->value = meta.get_def();
}
 
static void _prop_cmd_result_value(PropertyValue value, PropertyType type)
{
    switch(type)
    {
        case PropertyType::Int:
            intret(std::get<int>(value));
            break;
 
        case PropertyType::Float:
            floatret(std::get<float>(value));
            break;
 
        case PropertyType::Color:
            intret(std::get<bvec>(value).tohexcolor());
            break;
 
        case PropertyType::IntVec:
        {
            const ivec& v = std::get<ivec>(value);
            result(tempformatstring("%d %d %d", v.x, v.y, v.z));
            break;
        }
 
        case PropertyType::FloatVec:
        {
            const vec& v = std::get<vec>(value);
            result(tempformatstring("%f %f %f", v.x, v.y, v.z));
            break;
        }
 
        case PropertyType::String:
            result(std::get<std::string>(value).c_str());
            break;
 
        default: break;
    }
}
 
template<typename PropertyMetaT>
void Property<PropertyMetaT>::cmd_result() const
{
    _prop_cmd_result_value(value, get_type());
}
 
template<typename PropertyMetaT>
void Property<PropertyMetaT>::cmd_result_min() const
{
    _prop_cmd_result_value(meta.get_min(), get_type());
}
 
template<typename PropertyMetaT>
void Property<PropertyMetaT>::cmd_result_def() const
{
    _prop_cmd_result_value(meta.get_def(), get_type());
}
 
template<typename PropertyMetaT>
void Property<PropertyMetaT>::cmd_result_max() const
{
    _prop_cmd_result_value(meta.get_max(), get_type());
}
 
template<typename PropertyMetaT>
void Property<PropertyMetaT>::pack(std::vector<uint8_t>& buf) const
{
    size_t data_size = get_size();
 
    vectorput(buf, data_size);
 
    switch(get_type())
    {
        case PropertyType::Int:
        {
            vectorput(buf, get_int());
            break;
        }
 
        case PropertyType::Float:
        {
            vectorput(buf, get_float());
            break;
        }
 
        case PropertyType::Color:
        {
            vectorput(buf, get_color());
            break;
        }
 
        case PropertyType::IntVec:
        {
            vectorput(buf, get_ivec());
            break;
        }
 
        case PropertyType::FloatVec:
        {
            vectorput(buf, get_fvec());
            break;
        }
 
        case PropertyType::String:
        {
            std::string data = get_string();
            // Null-terminator not needed, since we know the size
            vectorput(buf, reinterpret_cast<const uint8_t*>(data.data()), data.size());
            break;
        }
 
        default: break;
    }
}
 
template<typename PropertyMetaT>
size_t Property<PropertyMetaT>::unpack(const uint8_t* buf, size_t buf_size)
{
    size_t buf_read = 0;
    const size_t* data_size_packed = nullptr;
 
    if(buf_size <= sizeof(*data_size_packed))
    {
        // conoutf("Error unpacking prop '%s': not enough data to get the size!", meta.get_name().c_str());
        return 0;
    }
 
    data_size_packed = reinterpret_cast<const size_t*>(buf);
 
    buf_read += sizeof(*data_size_packed);
 
    static auto size_check = [&](size_t needed_size)
    {
        if(buf_size - buf_read < needed_size)
        {
            // conoutf("Error unpacking prop '%s': not enough data!", meta.get_name().c_str());
            return false;
        }
 
        return true;
    };
 
    switch(get_type())
    {
        case PropertyType::Int:
        case PropertyType::Color:
        case PropertyType::Float:
            if(*data_size_packed != get_size())
            {
                // conoutf("Error unpacking prop '%s': unexpected data size! Wanted: %lu, got: %lu",
                //         meta.get_name().c_str(), get_size(), *data_size_packed);
 
                return 0;
            }
            break;
 
        default: break;
    }
 
    switch(get_type())
    {
        case PropertyType::Int:
        {
            if(!size_check(get_size()))
            {
                return 0;
            }
 
            int ival;
            memcpy(&ival, buf + buf_read, get_size());
            buf_read += get_size();
            value = ival;
            break;
        }
 
        case PropertyType::Float:
        {
            if(!size_check(get_size()))
            {
                return 0;
            }
 
            float fval;
            memcpy(&fval, buf + buf_read, get_size());
            buf_read += get_size();
            value = fval;
            break;
        }
 
        case PropertyType::Color:
        {
            if(!size_check(get_size()))
            {
                return 0;
            }
 
            bvec cval;
            memcpy(&cval, buf + buf_read, get_size());
            buf_read += get_size();
            value = cval;
            break;
        }
 
        case PropertyType::IntVec:
        {
            if(!size_check(get_size()))
            {
                return 0;
            }
 
            ivec ivecval;
            memcpy(&ivecval, buf + buf_read, get_size());
            buf_read += get_size();
            value = ivecval;
            break;
        }
 
        case PropertyType::FloatVec:
        {
            if(!size_check(get_size()))
            {
                return 0;
            }
 
            vec vecval;
            memcpy(&vecval, buf + buf_read, get_size());
            buf_read += get_size();
            value = vecval;
            break;
        }
 
        case PropertyType::String:
        {
            if(!size_check(*data_size_packed))
            {
                return 0;
            }
 
            std::string sval(reinterpret_cast<const char*>(buf + buf_read), *data_size_packed);
            buf_read += *data_size_packed;
            value = sval;
            break;
        }
 
        default: break;
    }
 
    return buf_read;
}
 
template<typename PropertyMetaT>
Property<PropertyMetaT>::Property(const PropertyMetaT& _meta) : meta(_meta)
{
    reset();
}
 
PropertyType PropertyMeta::get_type() const
{
    return type;
}
 
PropertyValue PropertyMeta::get_min() const
{
    return min;
}
 
PropertyValue PropertyMeta::get_def() const
{
    return def;
}
 
PropertyValue PropertyMeta::get_max() const
{
    return max;
}
 
std::string PropertyMeta::get_name() const
{
    return name;
}
 
void PropertyMeta::changed(std::any argument) const
{
    if(on_change)
    {
        on_change(argument);
    }
}
 
 
 
// Helper functions //
 
 
 
template<typename PropertyT, std::size_t N>
PropertyT* find_prop(std::string name, std::array<PropertyT, N>& props)
{
    for(PropertyT& prop : props)
    {
        if(prop.get_name() == name)
        {
            return &prop;
        }
    }
 
    return nullptr;
}
 
template<typename PropertyT, std::size_t N>
const PropertyT* find_prop(std::string name, const std::array<PropertyT, N>& props)
{
    for(const PropertyT& prop : props)
    {
        if(prop.get_name() == name)
        {
            return &prop;
        }
    }
 
    return nullptr;
}
 
template<typename PropertyT, std::size_t N>
bool set_prop(std::string name, PropertyValue value, std::array<PropertyT, N>& props,
              std::any on_change_arg = std::any())
{
    PropertyT* prop = find_prop(name, props);
    if(!prop)
    {
        // conoutf("Property %s not found!", name.c_str());
        return false;
    }
 
    prop->set(value, on_change_arg);
    return true;
}
 
template<typename PropertyMetaT, std::size_t N>
const PropertyMetaT* find_prop_meta(std::string name, const std::array<PropertyMetaT, N>& prop_metas)
{
    for(const PropertyMetaT& prop_meta : prop_metas)
    {
        if(prop_meta.get_name() == name)
        {
            return &prop_meta;
        }
    }
 
    return nullptr;
}
 
template<typename PropertyT, std::size_t N>
void pack_props(const std::array<PropertyT, N>& props, std::vector<uint8_t>& buf)
{
    for(const PropertyT& prop : props)
    {
        prop.pack(buf);
    }
}
 
template<typename PropertyT, std::size_t N>
size_t unpack_props(const std::vector<uint8_t>& buf, std::array<PropertyT, N>& props)
{
    size_t prop_idx = 0;
    size_t read_pos = 0;
 
    while(read_pos < buf.size())
    {
        if(prop_idx >= N)
        {
            break;
        }
 
        PropertyT &prop = props[prop_idx];
 
        int unpacked_size = prop.unpack(buf.data() + read_pos, buf.size() - read_pos);
        if(!unpacked_size)
        {
            break;
        }
 
        read_pos += unpacked_size;
        prop_idx++;
    }
 
    return prop_idx;
}
 
template<std::size_t N, typename PropertyT, std::size_t... Is, typename PropertyMetaT>
std::array<PropertyT, N> _make_props_array_impl(std::index_sequence<Is...>,
                                               const PropertyMetaT (&prop_meta)[N])
{
    return { PropertyT(prop_meta[Is])... };
}
 
template<std::size_t N, typename PropertyT, std::size_t... Is, typename PropertyMetaT>
std::array<PropertyT, N> make_props_array(const PropertyMetaT (&prop_meta)[N])
{
    return _make_props_array_impl<N, PropertyT>(std::make_index_sequence<N>{}, prop_meta);
}
 
}; // namespace prop
 
#endif // PROP_H_