ValueView.hpp

#pragma once
 
#include "util/Assert.hpp"
#include "util/config/ConfigConstraints.hpp"
#include "util/config/ConfigValue.hpp"
#include "util/config/Types.hpp"
 
#include <fmt/format.h>
 
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <optional>
#include <ostream>
#include <string>
#include <type_traits>
#include <utility>
 
namespace util::config {
 
class ClioConfigDefinition;

class ValueView {
public:
    ValueView(ConfigValue const& configVal);

    [[nodiscard]] std::string
    asString() const;

    [[nodiscard]] bool
    asBool() const;

    template <typename T>
    [[nodiscard]] T
    asIntType() const
    {
        if ((type() == ConfigType::Integer) && configVal_.get().hasValue()) {
            auto const val = std::get<int64_t>(configVal_.get().getValue());
            if (std::is_unsigned_v<T> && val < 0)
                ASSERT(false, "Int {} cannot be converted to the specified unsigned type", val);
 
            if (std::is_convertible_v<decltype(val), T>) {
                return static_cast<T>(val);
            }
        }
        ASSERT(false, "Value view is not of Int type");
        return 0;
    }

    [[nodiscard]] double
    asDouble() const;

    [[nodiscard]] float
    asFloat() const;

    [[nodiscard]] constexpr ConfigType
    type() const
    {
        return configVal_.get().type();
    }

    [[nodiscard]] bool constexpr hasValue() const
    {
        return configVal_.get().hasValue();
    }

    [[nodiscard]] bool constexpr isOptional() const
    {
        return configVal_.get().isOptional();
    }

    [[nodiscard]] constexpr std::optional<std::reference_wrapper<Constraint const>>
    getConstraint() const
    {
        return configVal_.get().getConstraint();
    }

    template <typename T>
    T
    getValueImpl() const
    {
        ASSERT(configVal_.get().hasValue(), "ConfigValue does not have a value");
        if constexpr (std::is_same_v<T, bool>) {
            ASSERT(type() == ConfigType::Boolean, "Value type is not a bool");
            return asBool();
        } else if constexpr (std::is_integral_v<T>) {
            ASSERT(type() == ConfigType::Integer, "Value type is not an int");
            return asIntType<T>();
        } else if constexpr (std::is_same_v<T, std::string>) {
            ASSERT(type() == ConfigType::String, "Value type is not a string");
            return asString();
        } else if constexpr (std::is_floating_point_v<T>) {
            ASSERT(
                type() == ConfigType::Double || type() == ConfigType::Integer,
                "Value type is not a floating point"
            );
            return asDouble();
        }
 
        std::unreachable();
    }

    template <typename T>
    std::optional<T>
    asOptional() const
    {
        ASSERT(isOptional(), "A Config Value is not an optional value");
        if (!hasValue())
            return std::nullopt;
 
        return std::make_optional(getValueImpl<T>());
    }

    friend std::ostream&
    operator<<(std::ostream& stream, ValueView value)
    {
        stream << value.configVal_;
        return stream;
    }
 
private:
    std::reference_wrapper<ConfigValue const> configVal_;
};
 
}  // namespace util::config