Config.hpp

//------------------------------------------------------------------------------
/*
    This file is part of clio: https://github.com/XRPLF/clio
    Copyright (c) 2022, the clio developers.
 
    Permission to use, copy, modify, and distribute this software for any
    purpose with or without fee is hereby granted, provided that the above
    copyright notice and this permission notice appear in all copies.
 
    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
    ANY  SPECIAL,  DIRECT,  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
 
#pragma once
 
#include "util/config/impl/Helpers.hpp"
 
#include <boost/json.hpp>
#include <boost/json/kind.hpp>
#include <boost/json/object.hpp>
#include <boost/json/value.hpp>
 
#include <chrono>
#include <cstdint>
#include <exception>
#include <filesystem>
#include <functional>
#include <optional>
#include <stdexcept>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
namespace util {
 
class Config final {
    boost::json::value store_;
    static constexpr char kSEPARATOR = '.';
 
public:
    using KeyType = std::string;
    using ArrayType = std::vector<Config>;
    using WriteCursorType = std::pair<std::optional<std::reference_wrapper<boost::json::value>>, KeyType>;
 
    explicit Config(boost::json::value store = {});
 
    //
    // Querying the store
    //
 
    operator bool() const noexcept;
 
    [[nodiscard]] bool
    contains(KeyType key) const;
 
    //
    // Key value access
    //
 
    template <typename Result>
    [[nodiscard]] std::optional<Result>
    maybeValue(KeyType key) const
    {
        auto maybeElement = lookup(key);
        if (maybeElement)
            return std::make_optional<Result>(checkedAs<Result>(key, *maybeElement));
        return std::nullopt;
    }
 
    template <typename Result>
    [[nodiscard]] Result
    value(KeyType key) const
    {
        return maybeValue<Result>(key).value();
    }
 
    template <typename Result>
    [[nodiscard]] Result
    valueOr(KeyType key, Result fallback) const
    {
        try {
            return maybeValue<Result>(key).value_or(fallback);
        } catch (impl::StoreException const&) {
            return fallback;
        }
    }
 
    template <typename Result>
    [[nodiscard]] Result
    valueOrThrow(KeyType key, std::string_view err) const
    {
        try {
            return maybeValue<Result>(key).value();
        } catch (std::exception const&) {
            throw std::runtime_error(std::string{err});
        }
    }
 
    [[nodiscard]] std::optional<ArrayType>
    maybeArray(KeyType key) const;
 
    [[nodiscard]] ArrayType
    array(KeyType key) const;
 
    [[nodiscard]] ArrayType
    arrayOr(KeyType key, ArrayType fallback) const;
 
    [[nodiscard]] ArrayType
    arrayOrThrow(KeyType key, std::string_view err) const;
 
    [[nodiscard]] Config
    section(KeyType key) const;
 
    [[nodiscard]] Config
    sectionOr(KeyType key, boost::json::object fallback) const;
 
    //
    // Direct self-value access
    //
 
    template <typename Result>
    [[nodiscard]] std::optional<Result>
    maybeValue() const
    {
        if (store_.is_null())
            return std::nullopt;
        return std::make_optional<Result>(checkedAs<Result>("_self_", store_));
    }
 
    template <typename Result>
    [[nodiscard]] Result
    value() const
    {
        return maybeValue<Result>().value();
    }
 
    template <typename Result>
    [[nodiscard]] Result
    valueOr(Result fallback) const
    {
        return maybeValue<Result>().valueOr(fallback);
    }
 
    template <typename Result>
    [[nodiscard]] Result
    valueOrThrow(std::string_view err) const
    {
        try {
            return maybeValue<Result>().value();
        } catch (std::exception const&) {
            throw std::runtime_error(std::string{err});
        }
    }
 
    [[nodiscard]] ArrayType
    array() const;
 
    static std::chrono::milliseconds
    toMilliseconds(float value);
 
private:
    template <typename Return>
    [[nodiscard]] Return
    checkedAs(KeyType key, boost::json::value const& value) const
    {
        using boost::json::value_to;
 
        auto errorIf = [&key, &value](bool condition) {
            if (condition) {
                throw std::runtime_error(
                    "Type for key '" + key + "' is '" + std::string{to_string(value.kind())} +
                    "' in JSON but requested '" + impl::typeName<Return>() + "'"
                );
            }
        };
 
        if constexpr (std::is_same_v<Return, bool>) {
            errorIf(not value.is_bool());
        } else if constexpr (std::is_same_v<Return, std::string>) {
            errorIf(not value.is_string());
        } else if constexpr (std::is_same_v<Return, double> or std::is_same_v<Return, float>) {
            errorIf(not value.is_number());
        } else if constexpr (std::is_convertible_v<Return, uint64_t> || std::is_convertible_v<Return, int64_t>) {
            errorIf(not value.is_int64() && not value.is_uint64());
        }
 
        return value_to<Return>(value);
    }
 
    std::optional<boost::json::value>
    lookup(KeyType key) const;
 
    WriteCursorType
    lookupForWrite(KeyType key);
};
 
class ConfigReader final {
public:
    static Config
    open(std::filesystem::path path);
};
 
}  // namespace util