ConfigDefinition.hpp

#pragma once
 
#include "util/Assert.hpp"
#include "util/config/Array.hpp"
#include "util/config/ConfigConstraints.hpp"
#include "util/config/ConfigFileInterface.hpp"
#include "util/config/ConfigValue.hpp"
#include "util/config/Error.hpp"
#include "util/config/ObjectView.hpp"
#include "util/config/ValueView.hpp"
 
#include <algorithm>
#include <chrono>
#include <cstddef>
#include <initializer_list>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <utility>
#include <variant>
#include <vector>
 
namespace util::config {

class ClioConfigDefinition {
public:
    using KeyValuePair = std::pair<std::string_view, std::variant<ConfigValue, Array>>;

    ClioConfigDefinition(std::initializer_list<KeyValuePair> pair);

    [[nodiscard]] std::optional<std::vector<Error>>
    parse(ConfigFileInterface const& config);

    [[nodiscard]] ObjectView
    getObject(std::string_view prefix, std::optional<std::size_t> idx = std::nullopt) const;

    [[nodiscard]] ValueView
    getValueView(std::string_view fullKey) const;

    template <typename T>
    T
    get(std::string_view fullKey) const
    {
        ASSERT(map_.contains(fullKey), "key {} does not exist in config", fullKey);
        auto const val = map_.at(fullKey);
        if (std::holds_alternative<ConfigValue>(val)) {
            return ValueView{std::get<ConfigValue>(val)}.getValueImpl<T>();
        }
        std::unreachable();
    }

    [[nodiscard]] ValueView
    getValueInArray(std::string_view fullKey, std::size_t index) const;

    [[nodiscard]] ArrayView
    getArray(std::string_view prefix) const;

    [[nodiscard]] bool
    contains(std::string_view key) const;

    [[nodiscard]] bool
    hasItemsWithPrefix(std::string_view key) const;

    [[nodiscard]] Array const&
    asArray(std::string_view key) const;

    [[nodiscard]] std::size_t
    arraySize(std::string_view prefix) const;

    static std::chrono::milliseconds
    toMilliseconds(float value);

    template <typename T>
    std::optional<T>
    maybeValue(std::string_view fullKey) const
    {
        return getValueView(fullKey).asOptional<T>();
    }

    [[nodiscard]] auto
    begin() const
    {
        return map_.begin();
    }

    [[nodiscard]] auto
    end() const
    {
        return map_.end();
    }
 
private:
    [[nodiscard]] auto
    getArrayIterator(std::string_view key) const
    {
        auto const fullKey = addBracketsForArrayKey(key);
        auto const it =
            std::ranges::find_if(map_, [&fullKey](auto pair) { return pair.first == fullKey; });
 
        ASSERT(it != map_.end(), "key {} does not exist in config", fullKey);
        ASSERT(std::holds_alternative<Array>(it->second), "Value of {} is not an array", fullKey);
 
        return it;
    }

    [[nodiscard]] static std::string
    addBracketsForArrayKey(std::string_view key)
    {
        std::string fullKey = std::string(key);
        if (!key.contains(".[]"))
            fullKey += ".[]";
        return fullKey;
    }
 
    std::unordered_map<std::string_view, std::variant<ConfigValue, Array>> map_;
};

ClioConfigDefinition&
getClioConfig();
 
}  // namespace util::config