ConfigValue.hpp

#pragma once
 
#include "util/Assert.hpp"
#include "util/OverloadSet.hpp"
#include "util/config/ConfigConstraints.hpp"
#include "util/config/Error.hpp"
#include "util/config/Types.hpp"
 
#include <fmt/format.h>
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <optional>
#include <ostream>
#include <string>
#include <string_view>
#include <variant>
 
namespace util::config {

class ConfigValue {
public:
    constexpr ConfigValue(ConfigType type) : type_(type)
    {
    }

    [[nodiscard]] ConfigValue&
    defaultValue(Value value, std::optional<std::string_view> description = std::nullopt)
    {
        auto const err = checkTypeConsistency(type_, value);
        if (err.has_value())
            ASSERT(false, "{}", err->error);
        description_ = description;
        value_ = value;
        return *this;
    }

    [[nodiscard]] std::optional<Error>
    setValue(Value value, std::optional<std::string_view> key = std::nullopt)
    {
        auto err = checkTypeConsistency(type_, value);
        if (err.has_value()) {
            err->error = fmt::format("{} {}", key.value_or("Unknown_key"), err->error);
            return err;
        }
 
        if (cons_.has_value()) {
            auto constraintCheck = cons_->get().checkConstraint(value);
            if (constraintCheck.has_value()) {
                constraintCheck->error =
                    fmt::format("{} {}", key.value_or("Unknown_key"), constraintCheck->error);
                return constraintCheck;
            }
        }
        value_ = value;
        return std::nullopt;
    }

    [[nodiscard]] constexpr ConfigValue&
    withConstraint(Constraint const& cons)
    {
        cons_ = std::reference_wrapper<Constraint const>(cons);
        ASSERT(cons_.has_value(), "Constraint must be defined");
 
        if (value_.has_value()) {
            auto const& temp = cons_.value().get();
            auto const& result = temp.checkConstraint(value_.value());
            if (result.has_value()) {
                // useful for specifying clear Error message
                std::string type;
                std::visit(
                    util::OverloadSet{
                        [&type](bool tmp) { type = fmt::format("bool {}", tmp); },
                        [&type](std::string const& tmp) { type = fmt::format("string {}", tmp); },
                        [&type](double tmp) { type = fmt::format("double {}", tmp); },
                        [&type](int64_t tmp) { type = fmt::format("int {}", tmp); },
                    },
                    value_.value()
                );
                ASSERT(false, "Value {} ConfigValue does not satisfy the set Constraint", type);
            }
        }
        return *this;
    }

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

    [[nodiscard]] constexpr ConfigType
    type() const
    {
        return type_;
    }

    [[nodiscard]] constexpr ConfigValue&
    optional()
    {
        optional_ = true;
        return *this;
    }

    [[nodiscard]] bool constexpr isOptional() const
    {
        return optional_;
    }

    [[nodiscard]] bool constexpr hasValue() const
    {
        return value_.has_value();
    }

    [[nodiscard]] Value const&
    getValue() const
    {
        ASSERT(value_.has_value(), "getValue() is called when there is no value set");
        return value_.value();
    }

    friend std::ostream&
    operator<<(std::ostream& stream, ConfigValue val)
    {
        stream << "- **Required**: " << (val.isOptional() ? "False" : "True") << "\n";
        stream << "- **Type**: " << val.type() << "\n";
        if (val.description_.has_value()) {
            stream << "- **Default value**: " << *val.description_ << "\n";
        } else if (val.hasValue()) {
            stream << "- **Default value**: `" << *val.value_ << "`\n";
        } else {
            stream << "- **Default value**: None\n";
        }
        stream << "- **Constraints**: ";
 
        if (val.getConstraint().has_value()) {
            stream << val.getConstraint()->get() << "\n";
        } else {
            stream << "None" << "\n";
        }
        return stream;
    }
 
private:
    static std::optional<Error>
    checkTypeConsistency(ConfigType type, Value value)
    {
        if (type == ConfigType::String && !std::holds_alternative<std::string>(value)) {
            return Error{"value does not match type string"};
        }
        if (type == ConfigType::Boolean && !std::holds_alternative<bool>(value)) {
            return Error{"value does not match type boolean"};
        }
        if (type == ConfigType::Double && (!std::holds_alternative<double>(value))) {
            if (std::holds_alternative<int64_t>(value))
                return std::nullopt;
            return Error{"value does not match type double"};
        }
        if (type == ConfigType::Integer && !std::holds_alternative<int64_t>(value)) {
            return Error{"value does not match type integer"};
        }
        return std::nullopt;
    }
 
    ConfigType type_{};
    bool optional_{false};
    std::optional<Value> value_;
    std::optional<std::reference_wrapper<Constraint const>> cons_;
    std::optional<std::string_view> description_;
};
 
}  // namespace util::config