parameter.h

#pragma once
 
#include "sound_bakery/core/core_include.h"
 
namespace sbk::engine
{
    class named_parameter;
    class float_parameter;
    class named_parameter_value;
 
    template <typename parameter_type>
    class SB_CLASS parameter : public sbk::core::database_object
    {
        REGISTER_REFLECTION(parameter, database_object)
 
        static_assert(std::is_arithmetic<parameter_type>::value);
 
    public:
        using parameter_property = sbk::core::property<parameter_type>;
 
        using local_parameter = std::pair<sbk_id, parameter_property>;
 
        using local_parameter_value_pair = std::pair<sbk_id, parameter_type>;
 
        parameter() = default;
 
        parameter(parameter_type min, parameter_type max)
            : sbk::core::database_object(), m_property(min, min, max), m_defaultValue(min)
        {
        }
 
        [[nodiscard]] parameter_type get() const { return m_property.get(); }
        [[nodiscard]] parameter_type get_default() const { return m_defaultValue; }
 
        void set(parameter_type value) { m_property.set(value); }
        void set_default(parameter_type value) { m_defaultValue = value; }
 
        [[nodiscard]] typename parameter_property::property_changed_delegate& get_delegate()
        {
            return m_property.get_delegate();
        }
 
        [[nodiscard]] local_parameter create_local_parameter_from_this() const
        {
            return local_parameter(get_database_id(), m_property);
        }
 
    private:
        parameter_type m_defaultValue;
        sbk::core::property<parameter_type> m_property;
    };
 
    class SB_CLASS float_parameter : public parameter<float>
    {
        REGISTER_REFLECTION(float_parameter, parameter)
    };
 
    class SB_CLASS int_parameter : public parameter<int>
    {
        REGISTER_REFLECTION(int_parameter, parameter)
    };
 
    class SB_CLASS named_parameter_value : public sbk::core::database_object
    {
    public:
        sbk::core::database_ptr<named_parameter> parentParameter;
 
        REGISTER_REFLECTION(named_parameter_value, database_object)
    };
 
    class SB_CLASS named_parameter : public parameter<sbk_id>
    {
        REGISTER_REFLECTION(named_parameter, parameter)
 
    public:
        named_parameter()
            : m_values(), parameter((std::numeric_limits<sbk_id>::min)(), (std::numeric_limits<sbk_id>::max)())
        {
        }
 
        sbk::core::database_ptr<named_parameter_value> add_new_value(const std::string_view name)
        {
            sbk::core::database_ptr<named_parameter_value> result;
 
            if (!name.empty())
            {
                if (const std::shared_ptr<named_parameter_value> parameterValue =
                        create_database_object<named_parameter_value>())
                {
                    parameterValue->set_database_name(name);
                    parameterValue->parentParameter = this;
 
                    result = parameterValue;
 
                    m_values.emplace(parameterValue);
                }
            }
 
            return result;
        }
 
        std::unordered_set<sbk::core::database_ptr<named_parameter_value>> get_values()
        {
            if (m_values.empty())
            {
                set_selected_value(add_new_value("None"));
            }
 
            return m_values;
        }
 
        void set_selected_value(sbk::core::database_ptr<named_parameter_value> value)
        {
            if (m_values.contains(value))
            {
                set(value.id());
            }
            else
            {
                BOOST_ASSERT(false);
            }
        }
 
        [[nodiscard]] sbk::core::database_ptr<named_parameter_value> get_selected_value() const
        {
            sbk::core::database_ptr<named_parameter_value> selected(get());
            selected.lookup();
            return selected;
        }
 
    private:
        std::unordered_set<sbk::core::database_ptr<named_parameter_value>> m_values;
    };
 
    using global_float_parameter = sbk::core::database_ptr<float_parameter>;
    using global_int_parameter   = sbk::core::database_ptr<named_parameter>;
 
    struct SB_CLASS global_parameter_list
    {
        std::unordered_set<global_float_parameter> floatParameters;
        std::unordered_set<global_int_parameter> intParameters;
    };
 
    struct SB_CLASS local_parameter_list
    {
        std::unordered_map<global_float_parameter, float_parameter::parameter_property> floatParameters;
        std::unordered_map<global_int_parameter, named_parameter::parameter_property> intParameters;
    };
}  // namespace sbk::engine