diff options
| -rw-r--r-- | lib/enumDetails.h | 102 | ||||
| -rw-r--r-- | lib/stream_support.h | 2 | ||||
| -rw-r--r-- | test/enumDetailsData.h | 15 | ||||
| -rw-r--r-- | test/test-enumDetails.cpp | 46 | ||||
| -rw-r--r-- | test/test-static-enumDetails.cpp | 126 |
5 files changed, 140 insertions, 151 deletions
diff --git a/lib/enumDetails.h b/lib/enumDetails.h index dfae082..49906d4 100644 --- a/lib/enumDetails.h +++ b/lib/enumDetails.h @@ -9,11 +9,11 @@ /// EnumDetailsBase // Shared helpers struct EnumDetailsBase { - template<size_t len> + template<size_t Len> constexpr static auto strArr(auto input, auto start, auto end) { - std::array<char, len> out; + std::array<char, Len> out; input.copy(out.begin(), end - start, start); return out; } @@ -33,22 +33,22 @@ protected: return std::string_view {__PRETTY_FUNCTION__}; }; - constexpr static auto typeNameStart {typeraw().find(SEARCH_TYPE) + SEARCH_TYPE.length()}; - constexpr static auto typeNameEnd {typeraw().find_first_of("];", typeNameStart)}; - constexpr static auto typeNameLen {typeNameEnd - typeNameStart}; - constexpr static auto typeNameArr {strArr<typeNameLen>(typeraw(), typeNameStart, typeNameEnd)}; + constexpr static auto TYPE_NAME_START {typeraw().find(SEARCH_TYPE) + SEARCH_TYPE.length()}; + constexpr static auto TYPE_NAME_END {typeraw().find_first_of("];", TYPE_NAME_START)}; + constexpr static auto TYPE_NAME_LEN {TYPE_NAME_END - TYPE_NAME_START}; + constexpr static auto TYPE_NAME_ARR {strArr<TYPE_NAME_LEN>(typeraw(), TYPE_NAME_START, TYPE_NAME_END)}; public: - constexpr static std::string_view typeName {typeNameArr.data(), typeNameArr.size()}; + constexpr static std::string_view TYPE_NAME {TYPE_NAME_ARR.data(), TYPE_NAME_ARR.size()}; }; /// EnumValueDetails // Extracts the value name and constructs string_views of the parts -template<auto value> struct EnumValueDetails : public EnumTypeDetails<decltype(value)> { +template<auto Value> struct EnumValueDetails : public EnumTypeDetails<decltype(Value)> { #ifndef ENUM_PROBE private: #endif - using T = EnumTypeDetails<decltype(value)>; + using T = EnumTypeDetails<decltype(Value)>; constexpr static auto raw() @@ -56,26 +56,23 @@ private: return std::string_view {__PRETTY_FUNCTION__}; }; - constexpr static auto nameStart {raw().find_last_of(": ") + 1}; - constexpr static auto nameEnd {raw().find_first_of("];", nameStart)}; - constexpr static auto nameLen {nameEnd - nameStart}; - constexpr static auto nameArr {EnumValueDetails::template strArr<nameLen>(raw(), nameStart, nameEnd)}; + constexpr static auto NAME_START {raw().find_last_of(": ") + 1}; + constexpr static auto NAME_END {raw().find_first_of("];", NAME_START)}; + constexpr static auto NAME_LEN {NAME_END - NAME_START}; + constexpr static auto NAME_ARR {EnumValueDetails::template strArr<NAME_LEN>(raw(), NAME_START, NAME_END)}; public: - constexpr static std::string_view valueName {nameArr.data(), nameArr.size()}; - constexpr static auto valid {valueName.back() < '0' || valueName.back() > '9'}; -#pragma GCC diagnostic push -#ifdef __clang__ -# pragma GCC diagnostic ignored "-Wenum-constexpr-conversion" -#endif - constexpr static auto raw_value {value}; -#pragma GCC diagnostic pop + constexpr static std::string_view VALUE_NAME {NAME_ARR.data(), NAME_ARR.size()}; + constexpr static auto VALID {VALUE_NAME.back() < '0' || VALUE_NAME.back() > '9'}; + constexpr static auto RAW_VALUE {Value}; }; /// EnumValueCollection // Customisation point for specifying the range of underlying values your enum can have template<typename E> struct EnumValueCollection { - using Vs = std::make_integer_sequence<int, 256>; + using Underlying = std::underlying_type_t<E>; + static constexpr Underlying UPPER = std::numeric_limits<Underlying>::max(); + using Vs = std::make_integer_sequence<Underlying, UPPER>; }; /// EnumDetails @@ -84,45 +81,36 @@ template<typename E> struct EnumDetails { #ifndef ENUM_PROBE private: #endif - template<auto... n> + using Underlying = std::underlying_type_t<E>; + + template<auto... N> constexpr static auto - get_valids(std::integer_sequence<int, n...>) + getValids(std::integer_sequence<Underlying, N...>) { -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#ifdef __clang__ -# pragma GCC diagnostic ignored "-Wenum-constexpr-conversion" -#endif - return std::array {EnumValueDetails<static_cast<E>(n)>::valid...}; -#pragma GCC diagnostic pop + return std::array {EnumValueDetails<static_cast<E>(N)>::VALID...}; } - template<auto... n> + template<auto... N> constexpr static auto - get_values(std::integer_sequence<int, n...>) + getValues(std::integer_sequence<Underlying, N...>) { -#pragma GCC diagnostic push -#ifdef __clang__ -# pragma GCC diagnostic ignored "-Wenum-constexpr-conversion" -#endif - return std::array {EnumValueDetails<static_cast<E>(n)>::raw_value...}; -#pragma GCC diagnostic pop + return std::array {EnumValueDetails<static_cast<E>(N)>::RAW_VALUE...}; } - template<auto... n> + template<auto... N> constexpr static auto - get_valueNames(std::integer_sequence<int, n...>) + getValueNames(std::integer_sequence<int, N...>) { - return std::array {EnumValueDetails<values[n]>::valueName...}; + return std::array {EnumValueDetails<VALUES[N]>::VALUE_NAME...}; } using EVC = EnumValueCollection<E>; - constexpr static auto valid_flags {get_valids(typename EVC::Vs {})}; - constexpr static auto valid_count {std::count_if(valid_flags.begin(), valid_flags.end(), std::identity {})}; + constexpr static auto VALID_FLAGS {getValids(typename EVC::Vs {})}; + constexpr static auto VALID_COUNT {std::count_if(VALID_FLAGS.begin(), VALID_FLAGS.end(), std::identity {})}; constexpr static auto - lookup(const auto key, const auto & search, - const auto & out) -> std::optional<typename std::decay_t<decltype(out)>::value_type> + lookup(const auto key, const auto & search, const auto & out) + -> std::optional<typename std::decay_t<decltype(out)>::value_type> { if (const auto itr = std::find(search.begin(), search.end(), key); itr != search.end()) { return out[static_cast<std::size_t>(std::distance(search.begin(), itr))]; @@ -131,32 +119,32 @@ private: } public: - constexpr static auto values {[]() { - constexpr auto values {get_values(typename EVC::Vs {})}; - static_assert(std::is_sorted(values.begin(), values.end()), "Candidate values must be sorted"); - std::array<E, valid_count> out; - std::copy_if(values.begin(), values.end(), out.begin(), [valid = valid_flags.begin()](auto) mutable { + constexpr static auto VALUES {[]() { + constexpr auto VALUES {getValues(typename EVC::Vs {})}; + static_assert(std::ranges::is_sorted(VALUES), "Candidate values must be sorted"); + std::array<E, VALID_COUNT> out; + std::copy_if(VALUES.begin(), VALUES.end(), out.begin(), [valid = VALID_FLAGS.begin()](auto) mutable { return *valid++; }); return out; }()}; - constexpr static auto names {get_valueNames(std::make_integer_sequence<int, valid_count> {})}; + constexpr static auto NAMES {getValueNames(std::make_integer_sequence<int, VALID_COUNT> {})}; constexpr static bool - is_valid(E value) noexcept + isValid(E value) noexcept { - return std::binary_search(values.begin(), values.end(), value); + return std::binary_search(VALUES.begin(), VALUES.end(), value); } constexpr static std::optional<E> parse(std::string_view name) noexcept { - return lookup(name, names, values); + return lookup(name, NAMES, VALUES); } constexpr static std::optional<std::string_view> - to_string(E value) noexcept + toString(E value) noexcept { - return lookup(value, values, names); + return lookup(value, VALUES, NAMES); } }; diff --git a/lib/stream_support.h b/lib/stream_support.h index 5f276fd..7f1df96 100644 --- a/lib/stream_support.h +++ b/lib/stream_support.h @@ -81,7 +81,7 @@ namespace std { inline std::ostream & operator<<(std::ostream & s, const E & e) { - return s << EnumTypeDetails<E>::typeName << "::" << EnumDetails<E>::to_string(e).value(); + return s << EnumTypeDetails<E>::TYPE_NAME << "::" << EnumDetails<E>::toString(e).value(); } template<typename T> diff --git a/test/enumDetailsData.h b/test/enumDetailsData.h index b7bd601..6383838 100644 --- a/test/enumDetailsData.h +++ b/test/enumDetailsData.h @@ -1,23 +1,24 @@ #pragma once +#include <cstdint> #include <enumDetails.h> -enum GlobalUnscoped { aa, b, c }; -enum class GlobalScoped { aa, b, c }; +enum GlobalUnscoped : uint8_t { Aa, B, C }; +enum class GlobalScoped : int8_t { Aa, B, C }; namespace ns { - enum Unscoped { aa, b, c }; - enum class Scoped { aa, b, c }; + enum Unscoped : int8_t { Aa, B, C }; + enum class Scoped : int8_t { Aa, B, C }; } namespace test1 { - enum class DefaultDense { a, bee, ci, de }; + enum class DefaultDense : int8_t { A, Bee, Ci, De }; } namespace test2 { - enum class NumberedSparse { a = 0, bee = 3, ci = -20, de = 100 }; + enum class NumberedSparse : int8_t { A = 0, Bee = 3, Ci = -20, De = 100 }; } template<> struct EnumValueCollection<test2::NumberedSparse> { // Any ordered integer_sequence which includes all enumeration values - using Vs = std::integer_sequence<int, -100, -20, 0, 3, 10, 100, 1000>; + using Vs = std::integer_sequence<int8_t, -100, -20, 0, 3, 10, 100, 110>; }; diff --git a/test/test-enumDetails.cpp b/test/test-enumDetails.cpp index 0e759e5..6bcd627 100644 --- a/test/test-enumDetails.cpp +++ b/test/test-enumDetails.cpp @@ -7,47 +7,47 @@ #include <enumDetails.h> #include <stream_support.h> -constexpr std::array INVALID_NAMES {"", "missing", "GlobalScoped::aa", "GlobalScoped", "ns::aa", "a", "bb"}; -constexpr std::array VALID_NAMES {"aa", "b", "c"}; -template<typename E> constexpr std::array VALID_VALUES {E::aa, E::b, E::c}; +constexpr std::array INVALID_NAMES {"", "missing", "GlobalScoped::Aa", "GlobalScoped", "ns::Aa", "A", "Bb"}; +constexpr std::array VALID_NAMES {"Aa", "B", "C"}; +template<typename E> constexpr std::array VALID_VALUES {E::Aa, E::B, E::C}; // Not a template, else Boost test framework throws printing the context constexpr std::array INVALID_VALUES {-1, 3, 20}; #define TESTS_FOR_TYPE(TYPE) \ - BOOST_DATA_TEST_CASE(invalid_check_##TYPE, INVALID_VALUES, in) \ + BOOST_DATA_TEST_CASE(invalid_check_##TYPE, INVALID_VALUES, input) \ { \ - BOOST_CHECK(!EnumDetails<TYPE>::is_valid(static_cast<TYPE>(in))); \ + BOOST_CHECK(!EnumDetails<TYPE>::isValid(static_cast<TYPE>(input))); \ } \ - BOOST_DATA_TEST_CASE(invalid_parse_##TYPE, INVALID_NAMES, in) \ + BOOST_DATA_TEST_CASE(invalid_parse_##TYPE, INVALID_NAMES, input) \ { \ - BOOST_CHECK(!EnumDetails<TYPE>::parse(in).has_value()); \ + BOOST_CHECK(!EnumDetails<TYPE>::parse(input).has_value()); \ } \ - BOOST_DATA_TEST_CASE(invalid_to_string_##TYPE, INVALID_VALUES, in) \ + BOOST_DATA_TEST_CASE(invalid_to_string_##TYPE, INVALID_VALUES, input) \ { \ - BOOST_CHECK(!EnumDetails<TYPE>::to_string(static_cast<TYPE>(in)).has_value()); \ + BOOST_CHECK(!EnumDetails<TYPE>::toString(static_cast<TYPE>(input)).has_value()); \ } \ - BOOST_DATA_TEST_CASE(valid_check_##TYPE, VALID_VALUES<TYPE>, in) \ + BOOST_DATA_TEST_CASE(valid_check_##TYPE, VALID_VALUES<TYPE>, input) \ { \ - BOOST_CHECK(EnumDetails<TYPE>::is_valid(in)); \ + BOOST_CHECK(EnumDetails<TYPE>::isValid(input)); \ } \ - BOOST_DATA_TEST_CASE(valid_parse_##TYPE, VALID_NAMES ^ VALID_VALUES<TYPE>, in, out) \ + BOOST_DATA_TEST_CASE(valid_parse_##TYPE, VALID_NAMES ^ VALID_VALUES<TYPE>, input, output) \ { \ - const auto v = EnumDetails<TYPE>::parse(in); \ - BOOST_CHECK_IF(vo, v.has_value()) { \ - BOOST_CHECK_EQUAL(v.value(), out); \ + const auto parsed = EnumDetails<TYPE>::parse(input); \ + BOOST_CHECK_IF(parsedOK, parsed.has_value()) { \ + BOOST_CHECK_EQUAL(parsed.value(), output); \ } \ } \ - BOOST_DATA_TEST_CASE(valid_to_string_##TYPE, VALID_VALUES<TYPE> ^ VALID_NAMES, in, out) \ + BOOST_DATA_TEST_CASE(valid_to_string_##TYPE, VALID_VALUES<TYPE> ^ VALID_NAMES, input, output) \ { \ - const auto v = EnumDetails<TYPE>::to_string(in); \ - BOOST_CHECK_IF(vo, v.has_value()) { \ - BOOST_CHECK_EQUAL(v.value(), out); \ + const auto parsed = EnumDetails<TYPE>::toString(input); \ + BOOST_CHECK_IF(parsedOK, parsed.has_value()) { \ + BOOST_CHECK_EQUAL(parsed.value(), output); \ } \ } TESTS_FOR_TYPE(GlobalScoped) TESTS_FOR_TYPE(GlobalUnscoped) -using ns_unscoped = ns::Unscoped; -using ns_scoped = ns::Scoped; -TESTS_FOR_TYPE(ns_unscoped) -TESTS_FOR_TYPE(ns_scoped) +using NsUnscoped = ns::Unscoped; +using NsScoped = ns::Scoped; +TESTS_FOR_TYPE(NsUnscoped) +TESTS_FOR_TYPE(NsScoped) diff --git a/test/test-static-enumDetails.cpp b/test/test-static-enumDetails.cpp index 5f81753..932a2af 100644 --- a/test/test-static-enumDetails.cpp +++ b/test/test-static-enumDetails.cpp @@ -3,76 +3,76 @@ #include <enumDetails.h> // Test type name -static_assert(EnumTypeDetails<GlobalUnscoped>::typeName == "GlobalUnscoped"); -static_assert(EnumTypeDetails<GlobalScoped>::typeName == "GlobalScoped"); -static_assert(EnumTypeDetails<ns::Unscoped>::typeName == "ns::Unscoped"); -static_assert(EnumTypeDetails<ns::Scoped>::typeName == "ns::Scoped"); +static_assert(EnumTypeDetails<GlobalUnscoped>::TYPE_NAME == "GlobalUnscoped"); +static_assert(EnumTypeDetails<GlobalScoped>::TYPE_NAME == "GlobalScoped"); +static_assert(EnumTypeDetails<ns::Unscoped>::TYPE_NAME == "ns::Unscoped"); +static_assert(EnumTypeDetails<ns::Scoped>::TYPE_NAME == "ns::Scoped"); -static_assert(EnumValueDetails<GlobalUnscoped::aa>::valueName == "aa"); -static_assert(EnumValueDetails<GlobalScoped::aa>::valueName == "aa"); -static_assert(EnumValueDetails<ns::Unscoped::aa>::valueName == "aa"); -static_assert(EnumValueDetails<ns::Scoped::aa>::valueName == "aa"); +static_assert(EnumValueDetails<GlobalUnscoped::Aa>::VALUE_NAME == "Aa"); +static_assert(EnumValueDetails<GlobalScoped::Aa>::VALUE_NAME == "Aa"); +static_assert(EnumValueDetails<ns::Unscoped::Aa>::VALUE_NAME == "Aa"); +static_assert(EnumValueDetails<ns::Scoped::Aa>::VALUE_NAME == "Aa"); namespace test1 { - static_assert(EnumValueDetails<DefaultDense::a>::valid); - static_assert(EnumValueDetails<DefaultDense::de>::valid); - static_assert(EnumValueDetails<static_cast<DefaultDense>(0)>::valid); - static_assert(EnumValueDetails<static_cast<DefaultDense>(3)>::valid); - static_assert(!EnumValueDetails<static_cast<DefaultDense>(-1)>::valid); - static_assert(!EnumValueDetails<static_cast<DefaultDense>(4)>::valid); - static_assert(EnumValueDetails<DefaultDense::a>::valueName == "a"); - static_assert(EnumValueDetails<DefaultDense::de>::valueName == "de"); - using ED_DD = EnumDetails<DefaultDense>; - static_assert(EnumValueCollection<DefaultDense>::Vs::size() == 256); - static_assert(ED_DD::valid_flags.size() == 256); - static_assert(ED_DD::values.size() == 4); - static_assert(std::is_sorted(ED_DD::values.begin(), ED_DD::values.end())); - static_assert(ED_DD::values.at(0) == DefaultDense::a); - static_assert(ED_DD::values.at(3) == DefaultDense::de); - static_assert(ED_DD::names.at(0) == "a"); - static_assert(ED_DD::names.at(3) == "de"); + static_assert(EnumValueDetails<DefaultDense::A>::VALID); + static_assert(EnumValueDetails<DefaultDense::De>::VALID); + static_assert(EnumValueDetails<static_cast<DefaultDense>(0)>::VALID); + static_assert(EnumValueDetails<static_cast<DefaultDense>(3)>::VALID); + static_assert(!EnumValueDetails<static_cast<DefaultDense>(-1)>::VALID); + static_assert(!EnumValueDetails<static_cast<DefaultDense>(4)>::VALID); + static_assert(EnumValueDetails<DefaultDense::A>::VALUE_NAME == "A"); + static_assert(EnumValueDetails<DefaultDense::De>::VALUE_NAME == "De"); + using EdDd = EnumDetails<DefaultDense>; + static_assert(EnumValueCollection<DefaultDense>::Vs::size() == 127); + static_assert(EdDd::VALID_FLAGS.size() == 127); + static_assert(EdDd::VALUES.size() == 4); + static_assert(std::ranges::is_sorted(EdDd::VALUES)); + static_assert(EdDd::VALUES.at(0) == DefaultDense::A); + static_assert(EdDd::VALUES.at(3) == DefaultDense::De); + static_assert(EdDd::NAMES.at(0) == "A"); + static_assert(EdDd::NAMES.at(3) == "De"); - static_assert(ED_DD::is_valid(DefaultDense::a)); - static_assert(ED_DD::is_valid(DefaultDense::de)); - static_assert(!ED_DD::is_valid(DefaultDense(-1))); - static_assert(!ED_DD::parse("").has_value()); - static_assert(!ED_DD::parse("nonsense").has_value()); - static_assert(ED_DD::parse("bee").value() == DefaultDense::bee); - static_assert(ED_DD::parse("ci").value() == DefaultDense::ci); - static_assert(ED_DD::to_string(DefaultDense::de).value() == "de"); - static_assert(!ED_DD::to_string(static_cast<DefaultDense>(10)).has_value()); + static_assert(EdDd::isValid(DefaultDense::A)); + static_assert(EdDd::isValid(DefaultDense::De)); + static_assert(!EdDd::isValid(DefaultDense(-1))); + static_assert(!EdDd::parse("").has_value()); + static_assert(!EdDd::parse("nonsense").has_value()); + static_assert(EdDd::parse("Bee").value() == DefaultDense::Bee); + static_assert(EdDd::parse("Ci").value() == DefaultDense::Ci); + static_assert(EdDd::toString(DefaultDense::De).value() == "De"); + static_assert(!EdDd::toString(static_cast<DefaultDense>(10)).has_value()); } namespace test2 { - static_assert(EnumValueDetails<NumberedSparse::bee>::valid); - static_assert(EnumValueDetails<static_cast<NumberedSparse>(0)>::valid); - static_assert(EnumValueDetails<static_cast<NumberedSparse>(3)>::valid); - static_assert(EnumValueDetails<static_cast<NumberedSparse>(-20)>::valid); - static_assert(EnumValueDetails<static_cast<NumberedSparse>(100)>::valid); - static_assert(!EnumValueDetails<static_cast<NumberedSparse>(2)>::valid); - static_assert(EnumValueDetails<NumberedSparse::a>::valueName == "a"); - static_assert(EnumValueDetails<NumberedSparse::de>::valueName == "de"); - using ED_NS = EnumDetails<NumberedSparse>; + static_assert(EnumValueDetails<NumberedSparse::Bee>::VALID); + static_assert(EnumValueDetails<static_cast<NumberedSparse>(0)>::VALID); + static_assert(EnumValueDetails<static_cast<NumberedSparse>(3)>::VALID); + static_assert(EnumValueDetails<static_cast<NumberedSparse>(-20)>::VALID); + static_assert(EnumValueDetails<static_cast<NumberedSparse>(100)>::VALID); + static_assert(!EnumValueDetails<static_cast<NumberedSparse>(2)>::VALID); + static_assert(EnumValueDetails<NumberedSparse::A>::VALUE_NAME == "A"); + static_assert(EnumValueDetails<NumberedSparse::De>::VALUE_NAME == "De"); + using EdNs = EnumDetails<NumberedSparse>; static_assert(EnumValueCollection<NumberedSparse>::Vs::size() == 7); - static_assert(ED_NS::values.size() == 4); - static_assert(ED_NS::valid_flags.size() == 7); - static_assert(std::is_sorted(ED_NS::values.begin(), ED_NS::values.end())); - static_assert(ED_NS::values.at(0) == NumberedSparse::ci); - static_assert(ED_NS::values.at(1) == NumberedSparse::a); - static_assert(ED_NS::values.at(2) == NumberedSparse::bee); - static_assert(ED_NS::values.at(3) == NumberedSparse::de); - static_assert(ED_NS::names.at(0) == "ci"); - static_assert(ED_NS::names.at(1) == "a"); - static_assert(ED_NS::names.at(2) == "bee"); - static_assert(ED_NS::names.at(3) == "de"); + static_assert(EdNs::VALUES.size() == 4); + static_assert(EdNs::VALID_FLAGS.size() == 7); + static_assert(std::ranges::is_sorted(EdNs::VALUES)); + static_assert(EdNs::VALUES.at(0) == NumberedSparse::Ci); + static_assert(EdNs::VALUES.at(1) == NumberedSparse::A); + static_assert(EdNs::VALUES.at(2) == NumberedSparse::Bee); + static_assert(EdNs::VALUES.at(3) == NumberedSparse::De); + static_assert(EdNs::NAMES.at(0) == "Ci"); + static_assert(EdNs::NAMES.at(1) == "A"); + static_assert(EdNs::NAMES.at(2) == "Bee"); + static_assert(EdNs::NAMES.at(3) == "De"); - static_assert(ED_NS::is_valid(NumberedSparse::a)); - static_assert(ED_NS::is_valid(NumberedSparse::de)); - static_assert(!ED_NS::is_valid(NumberedSparse(-1))); - static_assert(!ED_NS::parse("").has_value()); - static_assert(!ED_NS::parse("nonsense").has_value()); - static_assert(ED_NS::parse("bee").value() == NumberedSparse::bee); - static_assert(ED_NS::parse("ci").value() == NumberedSparse::ci); - static_assert(ED_NS::to_string(NumberedSparse::ci).value() == "ci"); - static_assert(!ED_NS::to_string(static_cast<NumberedSparse>(10)).has_value()); + static_assert(EdNs::isValid(NumberedSparse::A)); + static_assert(EdNs::isValid(NumberedSparse::De)); + static_assert(!EdNs::isValid(NumberedSparse(-1))); + static_assert(!EdNs::parse("").has_value()); + static_assert(!EdNs::parse("nonsense").has_value()); + static_assert(EdNs::parse("Bee").value() == NumberedSparse::Bee); + static_assert(EdNs::parse("Ci").value() == NumberedSparse::Ci); + static_assert(EdNs::toString(NumberedSparse::Ci).value() == "Ci"); + static_assert(!EdNs::toString(static_cast<NumberedSparse>(10)).has_value()); } |