|
| template<typename T , typename R , typename BinaryPredicate = std::equal_to<>, typename D = std::decay_t<T>> |
| using | enable_if_t = typename enable_if_enum< std::is_enum_v< D > &&std::is_invocable_r_v< bool, BinaryPredicate, char_type, char_type >, R >::type |
| |
| template<typename E , enum_subtype S, typename D = std::decay_t<E>> |
| using | entries_t = decltype((entries_v< D, S >)) |
| |
| template<typename T , std::enable_if_t< std::is_enum_v< std::decay_t< T >>, int > = 0> |
| using | enum_concept = T |
| |
| template<auto V, typename E = std::decay_t<decltype(V)>, std::enable_if_t< std::is_enum_v< E >, int > = 0> |
| using | enum_constant = std::integral_constant< E, V > |
| |
| template<typename F , typename V > |
| using | invoke_result_t = typename invoke_result< F, V >::type |
| |
| template<typename E , enum_subtype S, typename D = std::decay_t<E>> |
| using | names_t = decltype((names_v< D, S >)) |
| |
| template<typename E , enum_subtype S, typename Result , typename F , typename D = std::decay_t<E>, typename R = typename decltype(result_type<D, S, Result, F>())::type> |
| using | result_t = std::enable_if_t< std::is_enum_v< D > &&!std::is_same_v< R, nonesuch >, R > |
| |
| template<typename E , enum_subtype S, typename D = std::decay_t<E>> |
| using | values_t = decltype((values_v< D, S >)) |
| |
|
| template<typename E , enum_subtype S, typename F , std::size_t... I> |
| constexpr bool | all_invocable (std::index_sequence< I... >) |
| |
| template<typename BinaryPredicate > |
| constexpr bool | cmp_equal (string_view lhs, string_view rhs, [[maybe_unused]] BinaryPredicate &&p) noexcept(is_nothrow_invocable< BinaryPredicate >()) |
| |
| template<typename L , typename R > |
| constexpr bool | cmp_less (L lhs, R rhs) noexcept |
| |
| template<typename E , enum_subtype S, typename F , std::size_t... I> |
| constexpr auto | common_invocable (std::index_sequence< I... >) noexcept |
| |
| template<typename R , typename E , enum_subtype S, typename F , typename Def > |
| constexpr decltype(auto) | constexpr_switch (F &&f, E value, Def &&def) |
| |
| template<std::size_t I, std::size_t End, typename R , typename E , enum_subtype S, typename F , typename Def > |
| constexpr decltype(auto) | constexpr_switch_impl (F &&f, E value, Def &&def) |
| |
| template<typename E , enum_subtype S, std::size_t... I> |
| constexpr auto | entries (std::index_sequence< I... >) noexcept |
| |
| template<typename E , E V> |
| constexpr auto | enum_name () noexcept |
| |
| constexpr std::size_t | find (string_view str, char_type c) noexcept |
| |
| template<typename E , enum_subtype S, typename F , std::size_t... I> |
| constexpr auto | for_each (F &&f, std::index_sequence< I... >) |
| |
| template<typename E , std::enable_if_t< std::is_enum_v< std::decay_t< E >>, int > = 0> |
| std::string | format_as (E e) |
| |
| template<typename E , typename... Es> |
| constexpr optional< std::uintmax_t > | fuse_enum (E head, Es... tail) noexcept |
| |
| template<typename E > |
| constexpr optional< std::uintmax_t > | fuse_enum (E value) noexcept |
| |
| template<typename E > |
| constexpr optional< std::uintmax_t > | fuse_one_enum (optional< std::uintmax_t > hash, E value) noexcept |
| |
| template<typename BinaryPredicate > |
| constexpr bool | is_default_predicate () noexcept |
| |
| template<typename BinaryPredicate > |
| constexpr bool | is_nothrow_invocable () |
| |
| template<typename E , enum_subtype S, typename U = std::underlying_type_t<E>> |
| constexpr bool | is_sparse () noexcept |
| |
| template<typename E , auto V> |
| constexpr bool | is_valid () noexcept |
| |
| template<typename I > |
| constexpr I | log2 (I value) noexcept |
| |
| template<typename E > |
| constexpr auto | n () noexcept |
| |
| template<typename E , enum_subtype S, std::size_t... I> |
| constexpr auto | names (std::index_sequence< I... >) noexcept |
| |
| template<typename E , enum_subtype S, typename U = std::underlying_type_t<E>> |
| constexpr int | reflected_max () noexcept |
| |
| template<typename E , enum_subtype S, typename U = std::underlying_type_t<E>> |
| constexpr int | reflected_min () noexcept |
| |
| template<typename E , enum_subtype S, typename Result , typename F > |
| constexpr auto | result_type () noexcept |
| |
| template<typename T > |
| constexpr enum_subtype | subtype (std::false_type) noexcept |
| |
| template<typename E , typename U = std::underlying_type_t<E>> |
| constexpr enum_subtype | subtype (std::true_type) noexcept |
| |
| template<typename T , std::size_t N, std::size_t... I> |
| constexpr std::array< std::remove_cv_t< T >, N > | to_array (T(&a)[N], std::index_sequence< I... >) noexcept |
| |
| template<typename E > |
| constexpr auto | type_name () noexcept |
| |
| template<typename... Es> |
| constexpr auto | typesafe_fuse_enum (Es... values) noexcept |
| |
| template<typename E , int O, enum_subtype S, typename U = std::underlying_type_t<E>> |
| constexpr U | ualue (std::size_t i) noexcept |
| |
| template<typename E , enum_subtype S, std::size_t Size, int Min> |
| constexpr auto | valid_count () noexcept |
| |
| template<typename E , enum_subtype S, std::size_t Size, int Min, std::size_t I> |
| constexpr void | valid_count (bool *valid, std::size_t &count) noexcept |
| |
| template<typename E , int O, enum_subtype S, typename U = std::underlying_type_t<E>> |
| constexpr E | value (std::size_t i) noexcept |
| |
| template<typename E , enum_subtype S, std::size_t Size, int Min> |
| constexpr auto | values () noexcept |
| |
| template<typename E , enum_subtype S, typename U = std::underlying_type_t<E>> |
| constexpr auto | values () noexcept |
| |
| template<typename E , enum_subtype S, typename U = std::underlying_type_t<E>> |
| constexpr U | values_ors () noexcept |
| |
|
| template<typename... T> |
| constexpr bool | always_false_v = false |
| |
| template<typename E , enum_subtype S> |
| constexpr auto | count_v = values_v<E, S>.size() |
| |
| template<typename T = void> |
| constexpr auto | default_result_type_lambda = []() noexcept(std::is_nothrow_default_constructible_v<T>) { return T{}; } |
| |
| template<> |
| constexpr auto | default_result_type_lambda< void > = []() noexcept {} |
| |
| template<typename E , enum_subtype S> |
| constexpr auto | entries_v = entries<E, S>(std::make_index_sequence<count_v<E, S>>{}) |
| |
| template<typename E , E V> |
| constexpr auto | enum_name_v = enum_name<E, V>() |
| |
| template<typename , auto > |
| constexpr bool | is_enum_constexpr_static_cast_valid = true |
| |
| template<typename T > |
| constexpr bool | is_enum_v = std::is_enum_v<T> && std::is_same_v<T, std::decay_t<T>> |
| |
| template<typename E , enum_subtype S> |
| constexpr bool | is_reflected_v = is_reflected<std::decay_t<E>, S>{} |
| |
| template<typename E , enum_subtype S = subtype_v<E>> |
| constexpr bool | is_sparse_v = is_sparse<E, S>() |
| |
| template<typename E , enum_subtype S, typename U = std::underlying_type_t<E>> |
| constexpr auto | max_v = (count_v<E, S> > 0) ? static_cast<U>(values_v<E, S>.back()) : U{0} |
| |
| template<typename E , enum_subtype S, typename U = std::underlying_type_t<E>> |
| constexpr auto | min_v = (count_v<E, S> > 0) ? static_cast<U>(values_v<E, S>.front()) : U{0} |
| |
| template<typename E , enum_subtype S> |
| constexpr auto | names_v = names<E, S>(std::make_index_sequence<count_v<E, S>>{}) |
| |
| template<typename E , typename D = std::decay_t<E>> |
| constexpr auto | subtype_v = subtype<D>(std::is_enum<D>{}) |
| |
| template<typename E > |
| constexpr auto | type_name_v = type_name<E>() |
| |
| template<typename E , enum_subtype S> |
| constexpr auto | values_v = values<E, S>() |
| |