schema.h

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <cstddef>
#include <string_view>
#include <type_traits>
 
#include "cppfig/setting.h"
 
namespace cppfig {
 
namespace detail {
 
    template <typename T, typename... Types>
    struct IsOneOf : std::disjunction<std::is_same<T, Types>...> { };
 
    consteval auto IsPathPrefix(std::string_view prefix, std::string_view path) -> bool
    {
        return path.size() > prefix.size() && path.starts_with(prefix) && path[prefix.size()] == '.';
    }
 
    consteval auto IsPathWellFormed(std::string_view path) -> bool
    {
        if (path.empty() || path.front() == '.' || path.back() == '.') {
            return false;
        }
        for (std::size_t i = 1; i < path.size(); ++i) {
            if (path[i] == '.' && path[i - 1] == '.') {
                return false;
            }
        }
        return true;
    }
 
    template <typename... Settings>
    consteval auto AllPathsWellFormed() -> bool
    {
        constexpr std::array<std::string_view, sizeof...(Settings)> paths = { Settings::path... };
        for (auto path : paths) {
            if (!IsPathWellFormed(path)) {
                return false;
            }
        }
        return true;
    }
 
    template <typename... Settings>
    consteval auto AllPathsUnique() -> bool
    {
        constexpr std::array<std::string_view, sizeof...(Settings)> paths = { Settings::path... };
        for (std::size_t i = 0; i < paths.size(); ++i) {
            for (std::size_t j = i + 1; j < paths.size(); ++j) {
                if (paths[i] == paths[j] || IsPathPrefix(paths[i], paths[j]) || IsPathPrefix(paths[j], paths[i])) {
                    return false;
                }
            }
        }
        return true;
    }
 
}  // namespace detail
 
template <IsSetting... Settings>
class ConfigSchema {
public:
    static constexpr std::size_t size = sizeof...(Settings);
 
    static_assert(detail::AllPathsWellFormed<Settings...>(),
                  "Every path in ConfigSchema must be non-empty and free of empty dot-separated segments");
 
    static_assert(detail::AllPathsUnique<Settings...>(),
                  "All paths in ConfigSchema must be unique, and none may be a prefix of another");
 
    template <typename S>
    static constexpr bool has_setting = detail::IsOneOf<S, Settings...>::value;
 
    [[nodiscard]] static constexpr auto GetPaths() -> std::array<std::string_view, size>
    {
        return { Settings::path... };
    }
 
    [[nodiscard]] static constexpr auto Size() -> std::size_t { return size; }
 
    template <typename Fn>
    static void ForEachSetting(Fn&& fn)
    {
        (fn.template operator()<Settings>(), ...);
    }
};
 
template <IsSetting S>
using setting_value_type = typename S::value_type;
 
}  // namespace cppfig