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;
    }
}
 
 
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 set 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 set property value of '" + property_name));
    }
}
 
 
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));
    }
}
 
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;
};
 
} // namespace adtf_file