| Ndetail_direct_map | |
| Ndetail_hash | |
| Ndetail_io | |
| Ndetail_units | |
| ►Nkblib | The main namespace in which all entities from kblib are defined |
| Nasserts | |
| Nbest_lcgs | |
| Ncommon_lcgs | |
| ►Ndetail | The namespace used for implementation details within kblib |
| Capply_impl | |
| Carithmetic_type | Filter only arithmetic types |
| Carithmetic_type< T, true > | Filter only arithmetic types |
| Cbuildiota_impl | |
| Cbuildiota_impl< Array, false > | |
| Cbuildiota_impl< construct_with_size< Container, N >, false > | |
| Cbuildiota_impl< Container, true > | |
| Cfilter_signed | |
| Cfilter_signed< N, true > | |
| Cfilter_unsigned | |
| Cfilter_unsigned< N, true > | |
| ►Cnext_larger_signed | |
| Cfalse_compare | |
| Cno_dangle | |
| Cno_dangle< T && > | |
| Cnode | |
| Cpointer | |
| Cpointer< D, T, void_t< typename D::pointer > > | |
| Cstr_type | Converts arithmetic types to strings, but provides the identity transformation for all other types |
| Cstr_type< char, char > | Override for char to avoid conversion to integer |
| Cstr_type< char16_t, char16_t > | Override for char16_t to avoid conversion to integer |
| Cstr_type< char32_t, char32_t > | Override for char32_t to avoid conversion to integer |
| Cstr_type< T, void > | Performs a natural conversion to a stringlike type |
| Cstr_type< wchar_t, wchar_t > | Override for wchar_t to avoid conversion to integer |
| Ctag | |
| Ctuple_type | Given a std::variant T, provides the member type which is a tuple of the same types |
| Ctuple_type< std::variant< Ts... > > | Given a std::variant T, provides the member type which is a tuple of the same types |
| Ctype_list | |
| Ctype_map | |
| Ctype_map_el | |
| Cvalue | |
| Cvalues | |
| Cvalues< std::index_sequence< Idxs... >, Ts... > | |
| Ndetail_algorithm | |
| ►Ndetail_bits | |
| Carray_filter | |
| Carray_filter2 | |
| Carray_filter2< T[], S > | |
| Carray_filter2< T[N], S > | |
| Carray_filter< T[]> | |
| Carray_filter< T[N]> | |
| Carray_pun_proxy | |
| Cbitfield_proxy | A proxy reference type for BITFIELD-declared bitfields |
| Cpun_el | |
| Cpun_el< P, Type[], S, I, true > | |
| Cpun_el< P, Type[S], S, I, true > | |
| Cpun_proxy | |
| Cpunner_impl | |
| Cpunner_impl< S, std::index_sequence< Is... >, Types... > | |
| Ctrie_node | |
| Ndetail_convert | |
| ►Ndetail_cry | |
| Cvalue_and_index_base | |
| Cvalue_and_index_base< Range, std::enable_if_t< not std::is_reference_v< Range > > > | |
| ►Cvalue_and_index_impl | |
| Citerator | |
| Cvalue_index_pair | |
| ►Ndetail_direct_map | |
| Cstorage_for | |
| Cstorage_for< T, true > | |
| ►Ndetail_enumerate | |
| Cforce_copy_tag | |
| Ndetail_hash | |
| ►Ndetail_io | |
| Cbasic_teestreambuf | |
| ►Ndetail_iterators | |
| Cis_addable | |
| Cis_addable< T, U, void_t< decltype(std::declval< T & >()+std::declval< U & >())> > | |
| ►Ndetail_memory | |
| Cas_base_class | |
| Cas_base_class< R(&)(A) noexcept(E), false, false > | |
| Cas_base_class< T &, false, true > | |
| Cas_base_class< T, false, true > | |
| Cas_base_class< T, true, true > | |
| Cfilter_deleter_pointer | |
| Cfilter_deleter_pointer< D, T, void_t< typename D::pointer > > | |
| Clive_ptr_base | |
| Cnoop_t | |
| Con_destroy | |
| Crule_zero | |
| Ctemplate_param | |
| Ctemplate_param< C< T > > | |
| Cvalue_init | |
| ►Ndetail_poly | Implementation details for poly_obj |
| Cconstruct_conditional | |
| Cconstruct_conditional< construct_type::both > | |
| Cconstruct_conditional< construct_type::both_throw > | |
| Cconstruct_conditional< construct_type::copy_only > | |
| Cconstruct_conditional< construct_type::move > | |
| Cconstruct_conditional< construct_type::none > | |
| Cconstruct_conditional< construct_type::throw_move > | |
| Cerased_construct | |
| Cerased_hash_t | |
| Cerased_hash_t< T, void_t< fakestd::invoke_result_t< std::hash< T >, T > > > | |
| Cextract_derived_size | |
| Cextract_derived_size< T, void_if_t<(T::max_derived_size > sizeof(T))> > | |
| Ckblib_erased_hash_t | |
| Ckblib_erased_hash_t< T, void_t< fakestd::invoke_result_t< std::hash< T >, T > > > | |
| ►Ndetail_simple | |
| Csimple_range | |
| ►Ndetail_sort | |
| Csort_transform_impl | Sort data after applying an arbitrary transformation to it. The primary template handles the general case of arbitrary transformation and arbitrary compare predicate |
| Csort_transform_impl< RandomAccessIt, UnaryOperation, BinaryPredicate, SortKey, small_size, true, false, false, false > | Sort implementation for pointer to member object of non-fundamental type, so sort keys are constant time to extract (this is most similar to a general sort()) |
| Csort_transform_impl< RandomAccessIt, UnaryOperation, std::greater< LessT >, SortKey, small_size, M, false, true, false > | Sort implementation for key of radix sortable type type with reverse sorting |
| Csort_transform_impl< RandomAccessIt, UnaryOperation, std::greater< LessT >, SortKey, small_size, true, true, false, false > | Sort implementation for pointer to member object of fundamental non-integral type with reverse sorting, so sort keys are constant time to extract and compare |
| Csort_transform_impl< RandomAccessIt, UnaryOperation, std::greater< LessT >, SortKey, small_size, true, true, true, true > | Sort implementation for pointer to member object of integral type with reverse sorting, so we can do radix sort |
| Csort_transform_impl< RandomAccessIt, UnaryOperation, std::less< LessT >, SortKey, small_size, M, false, true, false > | Sort implementation for key of radix sortable type type with default sorting |
| Csort_transform_impl< RandomAccessIt, UnaryOperation, std::less< LessT >, SortKey, small_size, true, true, false, false > | Sort implementation for pointer to member object of fundamental non-integral type with default sorting, so sort keys are constant time to extract and compare |
| Csort_transform_impl< RandomAccessIt, UnaryOperation, std::less< LessT >, SortKey, small_size, true, true, true, true > | Sort implementation for pointer to member object of integral type with default sorting, so we can do radix sort |
| ►Ndetail_units | |
| Cis_si_ratio | |
| Cis_si_ratio< std::atto > | |
| Cis_si_ratio< std::centi > | |
| Cis_si_ratio< std::deca > | |
| Cis_si_ratio< std::deci > | |
| Cis_si_ratio< std::exa > | |
| Cis_si_ratio< std::femto > | |
| Cis_si_ratio< std::giga > | |
| Cis_si_ratio< std::hecto > | |
| Cis_si_ratio< std::kilo > | |
| Cis_si_ratio< std::mega > | |
| Cis_si_ratio< std::micro > | |
| Cis_si_ratio< std::milli > | |
| Cis_si_ratio< std::nano > | |
| Cis_si_ratio< std::peta > | |
| Cis_si_ratio< std::pico > | |
| Cis_si_ratio< std::ratio< 1 > > | |
| Cis_si_ratio< std::tera > | |
| Cnearest_ratio | |
| Cprefix | |
| Cunit_conversion | |
| ►Nfakestd | A namespace which holds all the C++14 implementations of C++17 standard library features. In C++17, it is simply defined as an alias to std |
| ►Ndetail | Implementation details for kblib::fakestd features |
| Cinvokable_r | |
| Cinvoke_of | |
| Cinvoke_result | |
| Cinvoke_result< decltype(void(invoke(std::declval< F >(), std::declval< Args >()...))), F, Args... > | |
| Cis_referenceable | |
| Cis_referenceable_impl | |
| Cnat | |
| Cnot_fn_t | |
| Cnothrow_invokable_r_imp | |
| Cnothrow_invokable_r_imp< true, false, Ret, Fp, Args... > | |
| Cnothrow_invokable_r_imp< true, true, Ret, Fp, Args... > | |
| Cnothrow_swappable_with | |
| Cnothrow_swappable_with< Tp, Up, false > | |
| Cswappable_with | |
| Cswappable_with< Tp, Up, false > | |
| Ctwo | |
| Cin_place_t | |
| Cinvoke_result | |
| Cis_invocable | |
| Cis_invocable_r | |
| Cis_nothrow_invocable | |
| Cis_nothrow_invocable_r | |
| Cis_nothrow_swappable | |
| Cis_nothrow_swappable_with | |
| Cis_swappable | |
| Cis_swappable_with | |
| Cmake_void | |
| ►Nfnv | |
| Cfnv_offset | The starting value for the FNVa hash algorithm, as a type trait |
| Cfnv_offset< std::uint32_t > | |
| Cfnv_offset< std::uint64_t > | |
| Cfnv_prime | The prime to use for the FNVa hash algorithm, as a type trait |
| Cfnv_prime< std::uint32_t > | |
| Cfnv_prime< std::uint64_t > | |
| Nicu_str_ops | |
| ►Nlcgs | |
| Nbest_lcgs | |
| Ncommon_lcgs | |
| Nliterals | |
| ►Nmulti_impl | |
| Cmulspan_iterator | |
| ►Nnums | |
| Cmax_t | Shorthand for std::numeric_limits::max() |
| Cmin_t | Shorthand for std::numeric_limits::min() |
| Cadjacent_iterator | TODO(killerbee13): Implement adjacent_iterator |
| Cadjuster | |
| Cback_insert_iterator_F | An OutputIterator that transforms the values assigned to it before inserting them into the back of a container |
| Cbasic_teestream | |
| Cbitfield | Implements a bitfield abstraction. May be used in a union with other bitfields |
| Cbuild_end_t | |
| Cbuild_iterator | |
| Cbuild_iterator< Container, true > | |
| Cclass_of | |
| Cclass_of< M T::* > | |
| Cclone_copy | Implements copy construction using a virtual clone method. This type is provided mostly as an example |
| ►Ccompact_bit_trie | |
| Citerator_t | |
| Ckey_type | |
| Ccond_ptr | |
| Ccond_ptr< T[], Deleter > | |
| Cconstant | |
| Cconstruct_with_capacity | |
| Cconstruct_with_size | |
| Cconsume_iterator | An OutputIterator that simply calls a provided functor for each value assigned to it |
| Ccontaining_ptr | A smart pointer to an object contained inside the smart pointer object |
| Ccontains_type | Determines if T is a type in Tuple, which must be a std::tuple |
| Ccontains_type< std::tuple< T, Ts... >, T > | |
| Ccontains_type< std::tuple< T, Ts... >, U > | |
| Ccontains_type< std::tuple<>, T > | |
| Ccontains_types | Determines if Lhs contains all of the types in Rhs, where both are std::tuples |
| Ccontains_types< Tuple, std::tuple< T, Ts... > > | |
| Ccontains_types< Tuple, std::tuple<> > | |
| Ccopy_const | |
| Ccopy_const< C, T &&, true > | |
| Ccopy_const< C, T &, true > | |
| Ccopy_const< C, T, true > | |
| ►Ccounting_back_insert_iterator | Like a std::back_insert_iterator, but it keeps track of how many insertions it has made, allowing an end iterator to be created |
| Cproxy_iterator | |
| Cdecrementer | A struct which decrements anything it is added to. Suitable for use as a Delta type for range_t |
| Cdefault_copy | Implements type erasure for copy construction |
| Cdefault_copy< Obj, false > | |
| Cdefault_destroy | Uses the class's virtual destructor |
| Cdefault_extract | |
| Cdefault_extract< Key, void_if_t< is_linear_container_v< Key > > > | |
| Cdefault_extract< KeyElem[], void_if_t< std::is_integral_v< KeyElem > > > | |
| Cdefault_move | Implements type erasure for move construction |
| Cdefault_move< Obj, false, nothrow, false > | |
| Cdefault_move< Obj, false, nothrow, true > | |
| Cdelayed_construct | |
| Cdirect_map | |
| Cdirect_map< Key, T, void > | |
| Cenumerate_iterator | |
| Cenumerate_t | |
| Cenumerate_t< Range, void > | |
| Cenumeration | |
| Cenumerator_iterator | |
| Cenumerator_t | |
| Cenumerator_t< Range, void > | |
| Cequivalent | A function object implementing the equivalence relationship over a comparison predicate |
| Cequivalent< Compare, void > | |
| Cequivalent< void, Obj > | |
| Cequivalent< void, void > | |
| Cexists | |
| Cexists_t | |
| Cextractor_policy_for | |
| Cextractor_policy_for< Container, void_t< decltype(std::declval< Container >()[0])> > | |
| Cfile_deleter | |
| Cfirst_bigger_than | |
| Cfirst_bigger_than< size, T > | |
| CFNV_hash | The primary template has to exist, but not be constructible, in order to be compatible with std::hash |
| CFNV_hash< bool, HashInt, void > | Hasher for bool |
| CFNV_hash< char, HashInt, void > | Hasher for char |
| CFNV_hash< Container, HashInt, void_if_t< value_detected< Container >::value and is_hashable_v< value_detected_t< Container > > and not hash_detected< Container >::value and is_iterable< Container >::value and not(is_contiguous< Container >::value and is_trivially_hashable_v< typename Container::value_type >) and not is_iterator_v< Container > > > | Container hasher, for non-trivial elements (or non-contiguous storage) |
| CFNV_hash< Container, HashInt, void_if_t<(is_contiguous_v< Container > and is_trivially_hashable_v< typename Container::value_type >)> > | Container hasher, for contiguously-stored trivial elements |
| CFNV_hash< delayed_construct< T >, void > | |
| CFNV_hash< signed char, HashInt, void > | Hasher for signed char |
| CFNV_hash< std::optional< T >, HashInt, void > | |
| CFNV_hash< std::variant< Ts... >, HashInt, void_if_t< detail_hash::all_hashable< std::tuple< Ts... > >()> > | |
| CFNV_hash< T, HashInt, void_if_t< not is_contiguous_v< T > and not std::is_integral< T >::value and not std::is_pointer< T >::value and is_trivially_hashable_v< T > > > | Hasher for any non-integral trivially copyable type that has no padding |
| CFNV_hash< T, HashInt, void_if_t< std::is_empty< T >::value > > | An empty type is treated as if it were a single null byte |
| CFNV_hash< T, HashInt, void_if_t< std::is_integral< T >::value and is_trivially_hashable_v< T > > > | Hasher for any integral type without padding type not explicitly mentioned above |
| CFNV_hash< T, HashInt, void_if_t< std::is_pointer< T >::value > > | Hasher for any pointer type |
| CFNV_hash< T, HashInt, void_if_t<(std::is_base_of< std::forward_iterator_tag, typename std::iterator_traits< T >::iterator_category >::value and not std::is_pointer< T >::value and not is_trivially_hashable_v< T > and std::is_pointer< typename fakestd::invoke_result< decltype(&T::operator->), T >::type >::value)> > | Hasher for any forward iterator type |
| CFNV_hash< Tuple, HashInt, void_if_t< detail_hash::all_hashable< Tuple >() and not is_trivially_hashable_v< Tuple > and(std::tuple_size< Tuple >::value > 0u) and not is_linear_container_v< Tuple > > > | Tuple-like (but not array-like) type hasher |
| CFNV_hash< unsigned char, HashInt, void > | Hasher for unsigned char |
| CFNV_hash< void, HashInt, void > | Transparent hasher for any hashable type |
| Cget_manip | A helper class for wrapping stream manipulators |
| Chas_member_swap | |
| Chas_reserve | True if and only if C contains an accessible reserve() member |
| Chash_detected | |
| Chash_detected< T, void_t< typename T::hasher > > | |
| Cheap_value | |
| Cheap_value2 | |
| Cheap_value2< T[], D > | |
| Cidentity | The identity function, as a function object |
| Cignore | Ignores its first template argument entirely, and returns its second |
| Cimplies | A metafunction for logical implication. That is, if A, then B. If not A, B is unimportant |
| Cimplies< true, false > | Logical implication is only not satisfied by true -> false |
| Cin_place_agg_t | |
| Cincrementer | A struct which increments anything it is added to. Suitable for use as a Delta type for range_t |
| Cindexer_extractor | |
| Cindirect_range | Allow range-for iteration of an iterator pair |
| Cintrusive_dual_map | |
| Cintrusive_hash_map | |
| Cirange_t | |
| Cis_aliasing_type | |
| Cis_aliasing_type< char > | |
| Cis_aliasing_type< unsigned char > | |
| Cis_bidirectional_iterator | |
| Cis_bidirectional_iterator< T, void_if_t< std::is_base_of< std::bidirectional_iterator_tag, typename std::iterator_traits< T >::iterator_category >::value > > | |
| Cis_bounded_array | |
| Cis_bounded_array< T[N]> | |
| Cis_callable | |
| Cis_character | Determine if the given type, ignoring const or reference qualifiers, is a character type |
| Cis_contiguous | |
| Cis_forward_iterator | |
| Cis_forward_iterator< T, void_if_t< std::is_base_of< std::forward_iterator_tag, typename std::iterator_traits< T >::iterator_category >::value > > | |
| Cis_hashable | |
| Cis_hashable< Key, void_if_t< std::is_constructible< FNV_hash< Key > >::value > > | |
| Cis_input_iterator | |
| Cis_input_iterator< T, void_if_t< std::is_base_of< std::input_iterator_tag, typename std::iterator_traits< T >::iterator_category >::value > > | |
| Cis_iterable | |
| Cis_iterable< Range, void_if_t< is_input_iterator< decltype(begin(std::declval< Range & >()))>::value > > | |
| Cis_iterable< T(&)[N], void > | |
| Cis_iterable< T[N], void > | |
| Cis_iterator | |
| Cis_iterator< T, void_t< decltype(*std::declval< T & >(), void(),++std::declval< T & >())> > | |
| Cis_linear_container | |
| Cis_optional | |
| Cis_optional< std::optional< U > > | |
| Cis_output_iterator_for | Determine if T is a valid output iterator to which values of type E may be written |
| Cis_output_iterator_for< T, E, void_t< decltype(*std::declval< T & >()++=std::declval< const E & >())> > | |
| Cis_radix_sortable | |
| Cis_radix_sortable< std::bitset< B >, void > | |
| Cis_radix_sortable< T, void_if_t< is_linear_container_v< T > and std::is_integral< typename T::value_type >::value > > | |
| Cis_radix_sortable< T, void_if_t< std::is_enum< T >::value > > | |
| Cis_radix_sortable< T, void_if_t< std::is_integral< T >::value > > | |
| Cis_random_access_iterator | |
| Cis_random_access_iterator< T, void_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< T >::iterator_category >::value > > | |
| Cis_resizable | |
| Cis_space | |
| Cis_trivial_transformation | |
| Cis_trivial_transformation< identity > | |
| Cis_trivially_hashable | |
| Cis_tuple_like | |
| Cis_tuple_like< T, void_t< typename std::tuple_element< 0, T >::type > > | |
| Cis_unbounded_array | |
| Cis_unbounded_array< T[]> | |
| Cis_variant_like | |
| Citerator_extractor | |
| Citerator_type_for | Type trait that determines the iterator type for a range |
| Citerator_type_for< Range, void_t< decltype(begin(std::declval< Range & >()))> > | |
| Citerator_type_for< T[N], void > | |
| Ckey_detected | |
| Ckey_detected< T, void_t< typename T::key_type > > | |
| Ckey_type_setlike | |
| Ckey_type_setlike< Container, true, false > | |
| Clexical_caster | |
| Clexical_caster< Same, Same > | |
| Clexical_caster< std::string, From > | |
| Clexical_caster< std::string, std::string > | |
| Clexical_caster< std::string_view, From > | |
| Clexical_caster< std::string_view, std::string > | |
| Clexical_caster< std::string_view, std::string_view > | |
| Clexical_caster< To, std::string > | |
| Clexical_caster< To, std::string_view > | |
| Clist_as_tuple | |
| Clist_as_tuple< Tuple< Ts... > > | |
| Clive_ptr | |
| Clive_ptr< const mT > | |
| ►Clive_wrapper | |
| C_destroy | |
| Clive_wrapper< const T > | |
| Cmapped_detected | |
| Cmapped_detected< T, void_t< typename T::mapped_type > > | |
| Cmax_t | Shorthand for std::numeric_limits::max() |
| Cmember_of | |
| Cmember_of< M T::* > | |
| Cmeta_type | |
| Cmeta_type< T > | |
| Cmetafunction_success | |
| Cmetafunction_success< T, void_t< typename T::type > > | |
| Cmin_t | Shorthand for std::numeric_limits::min() |
| Cmulti_range | |
| Cmulti_range< Iter1, EndIter, 0 > | |
| Cmulti_span | |
| Cnull_construct | |
| Cnull_construct< T, true > | |
| Cpadding_bits | |
| Cpoly_obj | Inline polymorphic object. Generally mimics the interfaces of std::optional and std::variant |
| Cpoly_obj_traits | Poly_obj_traits is a traits class template which abstracts the allowed operations on a polymorphic type hierarchy. Any operation allowed by the traits must be usable for the entire hierarchy, not just the base class |
| Cpunner | |
| CRAII_wrapper | |
| ►Crange_t | A range generator, similar to Python 3's range() |
| Citerator | A helper struct which acts as an iterator for the range elements, as they are generated on the fly |
| Creturn_assert | Essentially just like std::enable_if, but with a different name that makes it clearer what it does in the context of return type SFINAE |
| Creturn_assert< true, T > | |
| Creturn_type | |
| Creturn_type< R(Args...) const > | |
| Creturn_type< R(Args...) const volatile > | |
| Creturn_type< R(Args...) volatile > | |
| Creturn_type< R(Args...)> | |
| Csafe_signed | |
| Csafe_signed< N, std::enable_if_t< std::is_integral< N >::value, void > > | |
| Cshift_mask | |
| Csparse_trie_map | |
| Csparse_trie_set | |
| Cstack | |
| Cstate_size | |
| Cstate_size< std::discard_block_engine< Engine, P, R > > | |
| Cstate_size< std::independent_bits_engine< Engine, W, UIntType > > | |
| Cstate_size< std::linear_congruential_engine< UIntType, a, c, m > > | |
| Cstate_size< std::mersenne_twister_engine< UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f > > | |
| Cstate_size< std::shuffle_order_engine< Engine, K > > | |
| Cstate_size< std::subtract_with_carry_engine< UIntType, w, s, r > > | |
| Cstate_size< transform_engine< Engine, Transform > > | |
| Cto_pointer_impl | |
| Cto_pointer_impl< T * > | |
| Ctransform_engine | |
| Ctransform_iterator | An InputIterator that applies a transformation to the elements of the range |
| Ctrie | |
| Ctrie< KeyElem, T, Extractor, false > | |
| Ctrie< KeyElem[], T, Extractor, false > | |
| Ctrie_map | |
| Ctrie_qmap | |
| Ctrie_qset | |
| Ctrie_set | |
| Ctrivial_array | Std::array isn't constexpr enough in C++14, so a dedicated array class is needed for constexpr functions |
| Ctrivial_pair | Std::pair isn't constexpr enough, so I'm stuck with this. All I use it for is removing a temporary variable from calc_fib_size() |
| Ctrivial_seed_seq | |
| Ctype_constant | |
| Cunicode_widen | |
| Cunicode_widen< char16_t, char32_t > | |
| Cunion_pun | |
| Cunion_pun< Type[N], Storage > | |
| Cvalue_detected | |
| Cvalue_detected< T, void_t< typename T::value_type > > | |
| Cvalue_type_linear | |
| Cvalue_type_linear< Container, false, typename Container::value_type > | |
| Cvisitor | Helper class for std::visiting a std::variant |
| Cvoid_if | |
| Cvoid_if< true > | |
| Czip_iterator | |
| Czip_iterator< It1, It1, It2 > | |
| ►Nstd | |
| Chash< kblib::delayed_construct< T > > | |
| Ctuple_element< 0, ::kblib::enumeration< T > > | |
| Ctuple_element< 0, const volatile ::kblib::enumeration< T > > | |
| Ctuple_element< 0, kblib::detail_cry::value_index_pair< T > > | |
| Ctuple_element< 0, volatile ::kblib::enumeration< T > > | |
| Ctuple_element< 1, ::kblib::enumeration< T > > | Copies decay away the const |
| Ctuple_element< 1, const ::kblib::enumeration< T > > | Unless const is explicitly added |
| Ctuple_element< 1, const volatile ::kblib::enumeration< T > > | But you can also add const to a reference |
| Ctuple_element< 1, kblib::detail_cry::value_index_pair< T > > | |
| Ctuple_element< 1, volatile ::kblib::enumeration< T > > | References keep the same qualifications as the original |
| Ctuple_element< I, kblib::punner< Types... > > | |
| Ctuple_size< kblib::detail_cry::value_index_pair< T > > | |
| Ctuple_size< kblib::punner< Types... > > | |
| Ctuple_size<::kblib::construct_with_size< C, Size > > | |
| Ctuple_size<::kblib::enumeration< T > > | |
1.9.4