closed_ended.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <tagval/base.hpp>
#include <tagval/entry.hpp>
#include <tagval/open_ended.hpp>  // for detail::HasValuesT
#include <tagval/values.hpp>
 
#include <commons/fixed_string.hpp>
 
#include <expected>
#include <span>
#include <string_view>
 
namespace tagval {
 
template <comms::FixedString Id, typename Derived>
class ClosedEnded : public detail::HandleBase<Id, Derived> {
    using base_t = detail::HandleBase<Id, Derived>;
 
public:
    using base_t::base_t;
 
    template <typename E>
    [[nodiscard]] static const Derived& value() noexcept {
        static_assert(detail::HasValuesT<Derived>,
                      "tagval: kind type is missing `using values_t = tagval::Values<...>;`");
        static_assert(Derived::values_t::template contains<E>,
                      "Entry type is not listed in Derived::values_t");
        static const Derived h = base_t::make_handle(base_t::find_in(all_values(), E::code));
        return h;
    }
 
    [[nodiscard]] static std::span<const TagValMetadata> all_values() noexcept {
        static_assert(detail::HasValuesT<Derived>,
                      "tagval: kind type is missing `using values_t = tagval::Values<...>;`");
        static constexpr auto arr = values_metadata_array<typename Derived::values_t>();
        return std::span<const TagValMetadata>{arr};
    }
 
    [[nodiscard]] static Derived of(std::string_view code) {
        return base_t::of_impl(all_values(), code);
    }
 
    [[nodiscard]] static std::expected<Derived, ParseError> try_of(std::string_view code) noexcept {
        return base_t::try_of_impl(all_values(), code);
    }
};
 
}  // namespace tagval