kind_registry.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <tagval/closed_ended.hpp>
#include <tagval/descriptor.hpp>
#include <tagval/entry.hpp>
#include <tagval/open_ended.hpp>
 
#include <commons/color.hpp>
#include <commons/fixed_string.hpp>
#include <commons/icon.hpp>
 
#include <algorithm>
#include <concepts>
#include <functional>
#include <memory>
#include <optional>
#include <ranges>
#include <span>
#include <string_view>
#include <type_traits>
#include <variant>
#include <vector>
 
namespace tagval {
 
namespace detail {
template <typename T>
class KindViewFactory;
}  // namespace detail
 
enum class KindCategory { Closed, Open };
 
struct KindEntryView {
    std::string_view code;
    std::string_view label;
    std::optional<comms::Icon> icon;
    std::optional<comms::Color> color;
 
    [[nodiscard]] friend constexpr bool operator==(const KindEntryView&,
                                                   const KindEntryView&) noexcept = default;
};
 
namespace detail {
 
template <comms::FixedString Id, typename T>
constexpr KindCategory probe_kind(ClosedEnded<Id, T>*) noexcept {
    return KindCategory::Closed;
}
 
template <comms::FixedString Id, typename T>
constexpr KindCategory probe_kind(OpenEnded<Id, T>*) noexcept {
    return KindCategory::Open;
}
 
// Variadic ellipsis is intentional: it's the lowest-priority overload of
// the probe set, picked only when neither ClosedEnded nor OpenEnded matches.
// NOLINTNEXTLINE(cert-dcl50-cpp,modernize-avoid-variadic-functions)
constexpr std::monostate probe_kind(...) noexcept {
    return {};
}
 
template <typename T>
concept TagValKind = !std::same_as<decltype(probe_kind(static_cast<T*>(nullptr))), std::monostate>;
 
template <typename T>
    requires TagValKind<T>
[[nodiscard]] constexpr KindCategory category_of() noexcept {
    return probe_kind(static_cast<T*>(nullptr));
}
 
}  // namespace detail
 
class KindView {
public:
    using EmitFn = void (*)(void* user, const KindEntryView&);
    using WalkFn = void (*)(void* user, EmitFn emit);
    using FindFn = std::optional<KindEntryView> (*)(std::string_view code);
 
    constexpr KindView() noexcept = default;
 
    [[nodiscard]] constexpr TagValDescriptor descriptor() const noexcept {
        return descriptor_;
    }
    [[nodiscard]] constexpr std::string_view kind_id() const noexcept {
        return descriptor_.id;
    }
    [[nodiscard]] constexpr KindCategory category() const noexcept {
        return category_;
    }
    [[nodiscard]] constexpr bool is_closed_ended() const noexcept {
        return category_ == KindCategory::Closed;
    }
    [[nodiscard]] constexpr bool is_open_ended() const noexcept {
        return category_ == KindCategory::Open;
    }
 
    [[nodiscard]] std::vector<KindEntryView> values() const {
        std::vector<KindEntryView> out;
        for_each([&](const KindEntryView& e) { out.push_back(e); });
        return out;
    }
 
    template <std::invocable<const KindEntryView&> F>
    void for_each(F&& f) const {
        using FRef = std::remove_reference_t<F>;
        auto trampoline =
            +[](void* user, const KindEntryView& e) { std::invoke(*static_cast<FRef*>(user), e); };
        // f is captured by reference via the void* user-data slot, so the
        // user-supplied callable doesn't need to be copy-constructible.
        walk_(static_cast<void*>(std::addressof(f)), trampoline);
    }
 
    [[nodiscard]] std::optional<KindEntryView> find(const std::string_view code) const {
        return find_(code);
    }
 
    [[nodiscard]] friend constexpr bool operator==(const KindView& a, const KindView& b) noexcept {
        return a.descriptor_.id == b.descriptor_.id;
    }
 
private:
    template <typename T>
    friend class detail::KindViewFactory;
 
    TagValDescriptor descriptor_{};
    KindCategory category_{};
    WalkFn walk_ = nullptr;
    FindFn find_ = nullptr;
};
 
namespace detail {
 
template <typename T>
class KindViewFactory {
public:
    [[nodiscard]] static KindView build() {
        KindView v;
        v.descriptor_ = T::descriptor();
        v.category_ = category_of<T>();
        v.walk_ = &walk;
        v.find_ = &find;
        return v;
    }
 
private:
    static void walk(void* user, const KindView::EmitFn emit) {
        for (const auto& m : T::all_values()) {
            const KindEntryView kev{m.code, m.label, m.icon, m.color};
            emit(user, kev);
        }
    }
 
    static std::optional<KindEntryView> find(std::string_view code) {
        auto exp = T::try_of(code);
        if (!exp) {
            return std::nullopt;
        }
        return KindEntryView{exp->code(), exp->label(), exp->icon(), exp->color()};
    }
};
 
}  // namespace detail
 
class KindRegistry {
public:
    template <typename T>
        requires detail::TagValKind<T>
    static void register_kind() {
        auto& v = storage();
        const std::string_view id = T::kind_id();
        if (std::ranges::any_of(v, [&](const KindView& kv) { return kv.kind_id() == id; })) {
            return;
        }
        v.push_back(detail::KindViewFactory<T>::build());
    }
 
    [[nodiscard]] static std::span<const KindView> all() noexcept {
        return std::span<const KindView>{storage()};
    }
 
    [[nodiscard]] static auto all_closed() noexcept {
        return all() | std::views::filter([](const KindView& kv) { return kv.is_closed_ended(); });
    }
 
    [[nodiscard]] static auto all_open() noexcept {
        return all() | std::views::filter([](const KindView& kv) { return kv.is_open_ended(); });
    }
 
    [[nodiscard]] static const KindView* find(const std::string_view kind_id) noexcept {
        const auto& v = storage();
        const auto it =
            std::ranges::find_if(v, [&](const KindView& kv) { return kv.kind_id() == kind_id; });
        return it == v.end() ? nullptr : &*it;
    }
 
private:
    [[nodiscard]] static std::vector<KindView>& storage() {
        static std::vector<KindView> v;
        return v;
    }
};
 
}  // namespace tagval