configuration.h

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <utility>
#include <unordered_map>
#include <stdexcept>
#include <string_view>
 
namespace adtf_file
{
struct PropertyValue
{
    PropertyValue() = default;
    PropertyValue(const PropertyValue&) = default;
    PropertyValue(PropertyValue&&) = default;
    PropertyValue& operator=(const PropertyValue&) = default;
    PropertyValue& operator=(PropertyValue&&) = default;

    PropertyValue(std::string value, std::string type): value(std::move(value)), type(std::move(type))
    {
    }

    template<typename T, std::enable_if_t<std::is_unsigned<T>::value && !std::is_same<T, bool>::value, bool> = true>
    PropertyValue(T value): value(std::to_string(value)), type("unsigned")
    {
    }

    template<typename T, std::enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value, bool> = true>
    PropertyValue(T value): value(std::to_string(value)), type("signed")
    {
    }

    template<typename T, std::enable_if_t<std::is_floating_point<T>::value, bool> = true>
    PropertyValue(T value): value(std::to_string(value)), type("float")
    {
    }

    template<typename T, std::enable_if_t<std::is_same<T, bool>::value, bool> = true>
    PropertyValue(T value): value((value ? "true" : "false")), type("bool")
    {
    }

    PropertyValue(std::string_view string_value): value(string_value), type("string")
    {
    }

    std::string value;
    std::string type;
};

inline bool operator==(const PropertyValue& left, const PropertyValue& right)
{
    return left.type == right.type && left.value == right.value;
}

using Configuration = std::unordered_map<std::string, PropertyValue>;

inline Configuration operator+(const Configuration& config_left, const Configuration& config_right)
{
    Configuration result_configuration(config_left);
    for (const auto& current_right : config_right)
    {
        result_configuration.insert_or_assign(current_right.first, current_right.second);
    }
    return result_configuration;
}
 
namespace detail
{
template<typename T>
T propertyValueAs(const std::string& /*property_value*/)
{
    static_assert(sizeof(T) == -1,
                  "please use the specializations for bool, int64_t, uint64_t, double and std::string.");
}
 
template<>
inline bool propertyValueAs<bool>(const std::string& property_value)
{
    if (property_value == "true")
    {
        return true;
    }
    else if (property_value == "false")
    {
        return false;
    }
    else
    {
        return (std::stoll(property_value, 0, 0) != 0);
    }
}
 
template<>
inline uint64_t propertyValueAs<uint64_t>(const std::string& property_value)
{
    return std::stoull(property_value, 0, 0);
}
 
template<>
inline int64_t propertyValueAs<int64_t>(const std::string& property_value)
{
    return std::stoll(property_value, 0, 0);
}
 
template<>
inline uint32_t propertyValueAs<uint32_t>(const std::string& property_value)
{
    return std::stoul(property_value, 0, 0);
}
 
template<>
inline int32_t propertyValueAs<int32_t>(const std::string& property_value)
{
    return std::stol(property_value, 0, 0);
}
 
template<>
inline double propertyValueAs<double>(const std::string& property_value)
{
    return std::stod(property_value);
}
 
template<>
inline std::string propertyValueAs<std::string>(const std::string& property_value)
{
    return property_value;
}
 
struct ReservedProperties
{
    static constexpr auto reserved_prefix = "#__";
    static constexpr auto version = "#__version";
    static constexpr auto display_name = "#__display_name";
    static constexpr auto description = "#__description";
 
    static constexpr auto range_min = "#__range_min";
    static constexpr auto range_max = "#__range_max";
 
    static constexpr auto value_list_count = "#__value_list_count";
    static constexpr auto value_list_value = "#__value_list_value_";
    static constexpr auto value_list_name = "#__value_list_name_";
    static constexpr auto value_list_restricted = "#__value_list_restricted";
 
    static constexpr auto default_filename_extension = "#__default_filename_extension";
};
} // namespace detail

template<typename T>
T getPropertyValue(const Configuration& configuration, const std::string& property_name)
{
    try
    {
        auto const& property_value = configuration.at(property_name);
        if constexpr (std::is_arithmetic<T>::value)
        {
            if (property_value.type == "bool")
            {
                return (property_value.value == "true") ? 1 : 0;
            }
        }
        return detail::propertyValueAs<T>(property_value.value);
    }
    catch (...)
    {
        std::throw_with_nested(std::runtime_error("cannot get property value of '" + property_name));
    }
}

template<typename T>
T getPropertyValue(const Configuration& configuration, const std::string& property_name, const T& default_value)
{
    try
    {
        const auto& found = configuration.find(property_name);
        if (found != configuration.end())
        {
            if constexpr (std::is_arithmetic<T>::value)
            {
                if (found->second.type == "bool")
                {
                    return (found->second.value == "true") ? 1 : 0;
                }
            }
            return detail::propertyValueAs<T>(found->second.value);
        }
        else
        {
            return default_value;
        }
    }
    catch (...)
    {
        std::throw_with_nested(std::runtime_error("cannot get property value of '" + property_name));
    }
}

inline Configuration getSubConfiguration(const Configuration& configuration,
                                         const std::string& property_name,
                                         bool top_level_reserved_properties = false)
{
    const auto prefix = property_name + "/";
    Configuration sub_configuration;
    for (const auto& property : configuration)
    {
        if (property.first.find(prefix) == 0)
        {
            const auto name = property.first.substr(prefix.size());
            if (top_level_reserved_properties || name.find(detail::ReservedProperties::reserved_prefix) != 0)
            {
                sub_configuration.try_emplace(name, property.second);
            }
        }
    }
    return sub_configuration;
}

template<typename T>
void setPropertyValue(Configuration& configuration, const std::string& property_name, const T& property_value)
{
    try
    {
        configuration.insert_or_assign(property_name, PropertyValue(property_value));
    }
    catch (...)
    {
        std::throw_with_nested(std::runtime_error("cannot set property value of '" + property_name));
    }
}

inline void setFilePluginVersion(Configuration& configuration, const std::string& version)
{
    setPropertyValue(configuration, detail::ReservedProperties::version, version);
}

inline void setFilePluginDescription(Configuration& configuration, const std::string& description)
{
    setPropertyValue(configuration, detail::ReservedProperties::description, description);
}

inline void setPropertyDescription(Configuration& configuration,
                                   const std::string& property_name,
                                   const std::string& description)
{
    setPropertyValue(configuration, property_name + "/" + detail::ReservedProperties::description, description);
}

inline void setPropertyDisplayName(Configuration& configuration,
                                   const std::string& property_name,
                                   const std::string& display_name)
{
    setPropertyValue(configuration, property_name + "/" + detail::ReservedProperties::display_name, display_name);
}

template<typename T>
void setPropertyValueRange(Configuration& configuration, const std::string& property_name, const T& min, const T& max)
{
    setPropertyValue<T>(configuration, property_name + "/" + detail::ReservedProperties::range_min, min);
    setPropertyValue<T>(configuration, property_name + "/" + detail::ReservedProperties::range_max, max);
}

template<typename T>
void setPropertyValueList(Configuration& configuration,
                          const std::string& property_name,
                          const std::vector<std::pair<T, std::string>>& value_list,
                          bool restrict_to_values = true)
{
    setPropertyValue<unsigned int>(configuration, property_name + "/" + detail::ReservedProperties::value_list_count,
                                   static_cast<unsigned int>(value_list.size()));
    setPropertyValue<bool>(configuration, property_name + "/" + detail::ReservedProperties::value_list_restricted,
                           restrict_to_values);
 
    size_t index = 0;
    for (const auto& value : value_list)
    {
        setPropertyValue<T>(configuration,
                            property_name + "/" + detail::ReservedProperties::value_list_value + std::to_string(index),
                            value.first);
        setPropertyValue(configuration,
                         property_name + "/" + detail::ReservedProperties::value_list_name + std::to_string(index),
                         value.second);
        ++index;
    }
}

class Configurable
{
public:
    virtual ~Configurable() = default;
    virtual const Configuration& getConfiguration() const
    {
        return _configuration;
    }

    virtual void setConfiguration(const Configuration& configuration)
    {
        _configuration = _configuration + configuration;
    }
 
private:
    Configuration _configuration;
};

template<typename T = std::string>
class PropertyBuilder : public Configuration
{
public:
    PropertyBuilder(std::string name, T default_value):
        Configuration{{name, PropertyValue{std::move(default_value)}}}, name{std::move(name)}
    {
    }

    PropertyBuilder& setDescription(const std::string& description)
    {
        setPropertyDescription(*this, name, description);
        return *this;
    }

    PropertyBuilder& setDisplayName(const std::string& display_name)
    {
        setPropertyDisplayName(*this, name, display_name);
        return *this;
    }

    PropertyBuilder& setValueList(const std::vector<std::pair<T, std::string>>& value_list, bool restrict_to_values)
    {
        setPropertyValueList(*this, name, value_list, restrict_to_values);
        return *this;
    }

    PropertyBuilder& setMinMax(const T& min, const T& max)
    {
        setPropertyValueRange(*this, name, min, max);
        return *this;
    }
 
private:
    std::string name;
};

#define FILE_PLUGIN_META_INFORMATION(version, description)    \
    {                                                         \
        adtf_file::Configuration configuration;               \
        setFilePluginVersion(configuration, version);         \
        setFilePluginDescription(configuration, description); \
        setConfiguration(configuration);                      \
    }
 
} // namespace adtf_file