open_ended.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <tagval/base.hpp>
#include <tagval/entry.hpp>
#include <tagval/error.hpp>
#include <tagval/openended_registry.hpp>
#include <tagval/values.hpp>
 
#include <commons/fixed_string.hpp>
 
#include <concepts>
#include <expected>
#include <ranges>
#include <string>
#include <string_view>
 
namespace tagval {
 
namespace detail {
 
template <typename T>
concept HasValuesT = requires { typename T::values_t; };
 
}  // namespace detail
 
template <comms::FixedString Id, typename Derived>
class OpenEnded : public detail::HandleBase<Id, Derived> {
    using base_t = detail::HandleBase<Id, Derived>;
 
    template <typename Self = Derived>
    // NOLINTNEXTLINE(readability-identifier-naming)
    inline static const bool values_t_seeded_ = [] {
        if constexpr (detail::HasValuesT<Self>) {
            for (constexpr auto ptrs = values_metadata_pointers<typename Self::values_t>();
                 const auto* p : ptrs) {
                OpenEndedRegistry<Self>::add(p);
            }
        }
        return true;
    }();
 
public:
    using base_t::base_t;
 
    template <typename E>
    [[nodiscard]] static const Derived& value() noexcept {
        static_assert(std::same_as<typename E::owner_t, Derived>,
                      "Entry type's owner must match this kind");
        (void)values_t_seeded_<Derived>;
        static const Derived h = base_t::make_handle(OpenEndedRegistry<Derived>::find(E::code));
        return h;
    }
 
    [[nodiscard]] static auto all_values() noexcept {
        (void)values_t_seeded_<Derived>;
        return OpenEndedRegistry<Derived>::all() |
               std::views::transform(
                   [](const TagValMetadata* p) -> const TagValMetadata& { return *p; });
    }
 
    [[nodiscard]] static Derived of(std::string_view code) {
        (void)values_t_seeded_<Derived>;
        const TagValMetadata* m = OpenEndedRegistry<Derived>::find(code);
        if (m == nullptr) {
            std::string msg = "tagval: unknown code '";
            msg.append(code);
            msg += "' for kind '";
            msg.append(Id.view());
            msg += "'";
            throw UnknownCodeError{msg};
        }
        return base_t::make_handle(m);
    }
 
    [[nodiscard]] static std::expected<Derived, ParseError> try_of(std::string_view code) noexcept {
        (void)values_t_seeded_<Derived>;
        const TagValMetadata* m = OpenEndedRegistry<Derived>::find(code);
        if (m == nullptr) {
            return std::unexpected(ParseError{.code = std::string{code}, .kind_id = Id.view()});
        }
        return base_t::make_handle(m);
    }
};
 
}  // namespace tagval