| Ckblib::live_wrapper< T >::_destroy | |
| CAddr | |
| CAddr1 | |
| Ckblib::adjacent_iterator< ForwardIt, EndIt > | TODO(killerbee13): Implement adjacent_iterator |
| Ckblib::adjuster | |
| Ckblib::detail::apply_impl< F, Arg, typename > | |
| CCatch::Detail::Approx | |
| Ckblib::detail::arithmetic_type< T, bool > | Filter only arithmetic types |
| Ckblib::detail::arithmetic_type< T, true > | Filter only arithmetic types |
| ►Cstd::array | |
| Ckblib::detail_direct_map::storage_for< T, bool > | |
| Ckblib::detail_bits::array_filter< T > | |
| Ckblib::detail_bits::array_filter2< T, S > | |
| Ckblib::detail_bits::array_filter2< T[], S > | |
| Ckblib::detail_bits::array_filter2< T[N], S > | |
| Ckblib::detail_bits::array_filter< T[]> | |
| Ckblib::detail_bits::array_filter< T[N]> | |
| Ckblib::detail_bits::array_pun_proxy< Type, Storage > | |
| CCatch::Generators::as< T > | |
| ►Ckblib::detail_memory::as_base_class< T, bool, bool > | |
| Ckblib::detail_memory::on_destroy< T, D > | |
| Ckblib::detail_memory::rule_zero< T, Construct, Destroy > | |
| ►Ckblib::detail_memory::as_base_class< D > | |
| Ckblib::detail_memory::on_destroy< T, D > | |
| ►Ckblib::detail_memory::as_base_class< Deleter > | |
| Ckblib::cond_ptr< T[], Deleter > | |
| ►Ckblib::detail_memory::as_base_class< kblib::live_wrapper::_destroy > | |
| Ckblib::detail_memory::on_destroy< std::vector< kblib::live_wrapper ** >, kblib::live_wrapper::_destroy > | |
| Ckblib::detail_memory::as_base_class< R(&)(A) noexcept(E), false, false > | |
| ►Ckblib::detail_memory::as_base_class< std::default_delete< T > > | |
| Ckblib::cond_ptr< T, Deleter > | |
| ►Ckblib::detail_memory::as_base_class< std::vector< kblib::live_wrapper ** > > | |
| Ckblib::detail_memory::on_destroy< std::vector< kblib::live_wrapper ** >, kblib::live_wrapper::_destroy > | |
| Ckblib::detail_memory::as_base_class< T &, false, true > | |
| Ckblib::detail_memory::as_base_class< T, false, true > | |
| CCatch::AssertionHandler | |
| CCatch::AssertionInfo | |
| CCatch::AssertionReaction | |
| Ckblib::back_insert_iterator_F< Container, F > | An OutputIterator that transforms the values assigned to it before inserting them into the back of a container |
| Cbad_iterator< depth > | |
| Cbad_iterator< 0 > | |
| ►Cstd::basic_ostream | |
| Ckblib::basic_teestream< StreamA, StreamB > | |
| ►Cstd::basic_streambuf | |
| Ckblib::detail_io::basic_teestreambuf< detail_io::buf_for< StreamA >, detail_io::buf_for< StreamB > > | |
| Ckblib::detail_io::basic_teestreambuf< SB1_t, SB2_t > | |
| Ckblib::bitfield< offset, size, Storage > | Implements a bitfield abstraction. May be used in a union with other bitfields |
| Ckblib::bitfield< 0, 14, uint16_t > | |
| Ckblib::bitfield< 0, 16, uint16_t > | |
| Ckblib::bitfield< 0, 5, uint16_t > | |
| Ckblib::bitfield< 0, 8, uint16_t > | |
| Ckblib::bitfield< 10, 2, uint16_t > | |
| Ckblib::bitfield< 12, 3, uint16_t > | |
| Ckblib::bitfield< 5, 5, uint16_t > | |
| Ckblib::bitfield< 8, 7, uint16_t > | |
| Ckblib::detail_bits::bitfield_proxy< Parent, ReturnT, Set, Get > | A proxy reference type for BITFIELD-declared bitfields |
| ►Cbool_constant | |
| Ckblib::has_reserve< C > | True if and only if C contains an accessible reserve() member |
| Ckblib::is_contiguous< C > | |
| Ckblib::is_linear_container< Container > | |
| Ckblib::is_resizable< C > | |
| Ckblib::is_trivial_transformation< T > | |
| Ckblib::is_trivially_hashable< T > | |
| ►Cstd::bool_constant | |
| Ckblib::is_variant_like< T > | |
| Cbuffer | |
| Ckblib::build_end_t | |
| Ckblib::build_iterator< Container, ArrayLike > | |
| Ckblib::build_iterator< Container, true > | |
| Ckblib::detail::buildiota_impl< Container, bool,... > | |
| Ckblib::detail::buildiota_impl< Array, false > | |
| Ckblib::detail::buildiota_impl< construct_with_size< Container, N >, false > | |
| Ckblib::detail::buildiota_impl< Container, true > | |
| CCatch::Capturer | |
| CCatch::Matchers::StdString::CasedString | |
| CCatch::CaseSensitive | |
| CCatch_global_namespace_dummy | |
| Ckblib::class_of< T > | |
| Ckblib::class_of< M T::* > | |
| Ckblib::clone_copy< Obj > | Implements copy construction using a virtual clone method. This type is provided mostly as an example |
| Ckblib::compact_bit_trie< Key, key_range, Value > | |
| ►Cstd::conditional< sizeof(T) > size | |
| Ckblib::first_bigger_than< size, T, Ts > | |
| ►Cstd::conditional_t< sizeof(T) > size | |
| Ckblib::first_bigger_than< size, T > | |
| Ckblib::detail_poly::construct_conditional< traits > | |
| Ckblib::detail_poly::construct_conditional< construct_type::both > | |
| Ckblib::detail_poly::construct_conditional< construct_type::both_throw > | |
| Ckblib::detail_poly::construct_conditional< construct_type::copy_only > | |
| Ckblib::detail_poly::construct_conditional< construct_type::move > | |
| Ckblib::detail_poly::construct_conditional< construct_type::none > | |
| Ckblib::detail_poly::construct_conditional< construct_type::throw_move > | |
| ►Ckblib::detail_poly::construct_conditional< detail_poly::make_ctype(Traits::copyable, Traits::movable, Traits::nothrow_movable)> | |
| Ckblib::poly_obj< Obj, Capacity, Traits > | Inline polymorphic object. Generally mimics the interfaces of std::optional and std::variant |
| Ckblib::construct_with_capacity< C, size > | |
| Ckblib::construct_with_size< C, size > | |
| Ckblib::consume_iterator< F > | An OutputIterator that simply calls a provided functor for each value assigned to it |
| Ckblib::containing_ptr< T > | A smart pointer to an object contained inside the smart pointer object |
| Ckblib::contains_type< Tuple, T > | Determines if T is a type in Tuple, which must be a std::tuple |
| ►Ckblib::contains_type< std::tuple< char, wchar_t, char16_t, char32_t >, std::decay_t< C > > | |
| Ckblib::is_character< C > | Determine if the given type, ignoring const or reference qualifiers, is a character type |
| ►Ckblib::contains_type< std::tuple< Ts... >, U > | |
| Ckblib::contains_type< std::tuple< T, Ts... >, U > | |
| Ckblib::contains_types< Lhs, Rhs > | Determines if Lhs contains all of the types in Rhs, where both are std::tuples |
| ►CTraits::copy_t | |
| ►Ckblib::detail_poly::erased_construct< poly_obj_traits< Obj > > | |
| Ckblib::poly_obj< Obj, Capacity, Traits > | Inline polymorphic object. Generally mimics the interfaces of std::optional and std::variant |
| Ckblib::detail_poly::erased_construct< Traits > | |
| Ckblib::counting_back_insert_iterator< Container > | Like a std::back_insert_iterator, but it keeps track of how many insertions it has made, allowing an end iterator to be created |
| CCatch::Counts | |
| CCatch::Decomposer | |
| Ckblib::decrementer | A struct which decrements anything it is added to. Suitable for use as a Delta type for range_t |
| Ckblib::default_copy< Obj, copyable > | Implements type erasure for copy construction |
| Ckblib::default_copy< Obj, false > | |
| ►Ckblib::default_copy< Obj, true > | |
| Ckblib::default_move< Obj, false, nothrow, true > | |
| Ckblib::default_destroy< Obj > | Uses the class's virtual destructor |
| Ckblib::default_extract< Key, typename > | |
| Ckblib::default_extract< Key, void_if_t< is_linear_container_v< Key > > > | |
| Ckblib::default_extract< KeyElem[], void_if_t< std::is_integral_v< KeyElem > > > | |
| Ckblib::default_move< Obj, movable, nothrow, copyable > | Implements type erasure for move construction |
| Ckblib::default_move< Obj, false, nothrow, false > | |
| Ckblib::delayed_construct< T > | |
| ►CTraits::destroy_t | |
| Ckblib::detail_poly::erased_construct< poly_obj_traits< Obj > > | |
| Ckblib::detail_poly::erased_construct< Traits > | |
| Ckblib::direct_map< Key, T, allocator > | |
| Ckblib::direct_map< Key, T, void > | |
| Cempty_t | |
| ►Cstd::enable_if | |
| Ckblib::fakestd::detail::invoke_of< Fp, Args > | |
| Ckblib::enumerate_iterator< It > | |
| Ckblib::enumerate_t< It, EndIt > | |
| Ckblib::enumerate_t< Range, void > | |
| Ckblib::enumeration< T > | |
| Ckblib::enumeration< nested_value > | |
| Ckblib::enumerator_iterator< It > | |
| Ckblib::enumerator_t< It, EndIt > | |
| Ckblib::enumerator_t< Range, void > | |
| CCatch::Detail::EnumInfo | |
| Ckblib::equivalent< Compare, Obj > | A function object implementing the equivalence relationship over a comparison predicate |
| Ckblib::equivalent< Compare, void > | |
| Ckblib::equivalent< void, Obj > | |
| Ckblib::equivalent< void, void > | |
| Ckblib::detail_poly::erased_hash_t< T, hash > | |
| Ckblib::detail_poly::erased_hash_t< T, void_t< fakestd::invoke_result_t< std::hash< T >, T > > > | |
| Cexample | |
| ►Cstd::exception | |
| CCatch::GeneratorException | |
| CCatch::GeneratorException | |
| CCatch::ExceptionTranslatorRegistrar | |
| Ckblib::exists_t< iterator > | |
| CCatch::ExprLhs< LhsT > | |
| Ckblib::extractor_policy_for< Container, typename > | |
| Ckblib::extractor_policy_for< Container, void_t< decltype(std::declval< Container >()[0])> > | |
| Ckblib::detail::next_larger_signed< T >::false_compare | |
| ►Cstd::false_type | |
| ►Ckblib::metafunction_success< fakestd::invoke_result< T... > > | |
| Ckblib::is_callable< T > | |
| CCatch::always_false< T > | |
| CCatch::always_false< T > | |
| ►CCatch::detail::is_range_impl< T, typename > | |
| CCatch::is_range< T > | |
| CCatch::is_range< T > | |
| CCatch::detail::is_range_impl< T, typename > | |
| Ckblib::contains_type< std::tuple<>, T > | |
| Ckblib::detail_iterators::is_addable< T, U, typename > | |
| Ckblib::detail_units::is_si_ratio< R > | |
| Ckblib::fakestd::detail::nothrow_swappable_with< Tp, Up, false > | |
| Ckblib::fakestd::detail::swappable_with< Tp, Up, false > | |
| Ckblib::hash_detected< T, typename > | |
| Ckblib::is_aliasing_type< T > | |
| Ckblib::is_bidirectional_iterator< T, typename > | |
| Ckblib::is_bounded_array< T > | |
| Ckblib::is_forward_iterator< T, typename > | |
| Ckblib::is_hashable< Key, typename > | |
| Ckblib::is_input_iterator< T, typename > | |
| Ckblib::is_iterable< Range, typename > | |
| Ckblib::is_iterator< T, typename > | |
| Ckblib::is_optional< T > | |
| Ckblib::is_output_iterator_for< T, E, typename > | Determine if T is a valid output iterator to which values of type E may be written |
| Ckblib::is_radix_sortable< T, typename > | |
| Ckblib::is_random_access_iterator< T, typename > | |
| Ckblib::is_tuple_like< T, typename > | |
| Ckblib::is_unbounded_array< T > | |
| Ckblib::key_detected< T, typename > | |
| Ckblib::mapped_detected< T, typename > | |
| Ckblib::metafunction_success< T, typename > | |
| Ckblib::unicode_widen< T, U > | |
| Ckblib::value_detected< T, typename > | |
| Ckblib::file_deleter< F, D, P > | |
| Ckblib::detail_memory::filter_deleter_pointer< D, T, V > | |
| Ckblib::detail_memory::filter_deleter_pointer< D, T, void_t< typename D::pointer > > | |
| Ckblib::detail::filter_signed< N, bool > | |
| Ckblib::detail::filter_signed< N, true > | |
| Ckblib::detail::filter_unsigned< N, bool > | |
| Ckblib::detail::filter_unsigned< N, true > | |
| Ckblib::FNV_hash< Key, HashInt, typename > | The primary template has to exist, but not be constructible, in order to be compatible with std::hash |
| Ckblib::FNV_hash< bool, HashInt, void > | Hasher for bool |
| Ckblib::FNV_hash< char, HashInt, void > | Hasher for char |
| Ckblib::FNV_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) |
| Ckblib::FNV_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 |
| Ckblib::FNV_hash< delayed_construct< T >, void > | |
| Ckblib::FNV_hash< signed char, HashInt, void > | Hasher for signed char |
| Ckblib::FNV_hash< std::optional< T >, HashInt, void > | |
| Ckblib::FNV_hash< std::variant< Ts... >, HashInt, void_if_t< detail_hash::all_hashable< std::tuple< Ts... > >()> > | |
| Ckblib::FNV_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 |
| Ckblib::FNV_hash< T, HashInt, void_if_t< std::is_empty< T >::value > > | An empty type is treated as if it were a single null byte |
| Ckblib::FNV_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 |
| Ckblib::FNV_hash< T, HashInt, void_if_t< std::is_pointer< T >::value > > | Hasher for any pointer type |
| Ckblib::FNV_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 |
| Ckblib::FNV_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 |
| Ckblib::FNV_hash< unsigned char, HashInt, void > | Hasher for unsigned char |
| Ckblib::FNV_hash< void, HashInt, void > | Transparent hasher for any hashable type |
| Ckblib::fnv::fnv_offset< UInt > | The starting value for the FNVa hash algorithm, as a type trait |
| Ckblib::fnv::fnv_prime< UInt > | The prime to use for the FNVa hash algorithm, as a type trait |
| Ckblib::detail_enumerate::force_copy_tag | |
| ►CCatch::Generators::GeneratorUntypedBase | |
| ►CCatch::Generators::IGenerator< std::vector< T > > | |
| CCatch::Generators::ChunkGenerator< T > | |
| CCatch::Generators::ChunkGenerator< T > | |
| ►CCatch::Generators::IGenerator< Float > | |
| CCatch::Generators::RandomFloatingGenerator< Float > | |
| CCatch::Generators::RandomFloatingGenerator< Float > | |
| ►CCatch::Generators::IGenerator< Integer > | |
| CCatch::Generators::RandomIntegerGenerator< Integer > | |
| CCatch::Generators::RandomIntegerGenerator< Integer > | |
| CCatch::Generators::IGenerator< std::vector< T > > | |
| CCatch::Generators::IGenerator< Float > | |
| CCatch::Generators::IGenerator< Integer > | |
| ►CCatch::Generators::IGenerator< T > | |
| CCatch::Generators::FilterGenerator< T, Predicate > | |
| CCatch::Generators::FilterGenerator< T, Predicate > | |
| CCatch::Generators::FixedValuesGenerator< T > | |
| CCatch::Generators::FixedValuesGenerator< T > | |
| CCatch::Generators::Generators< T > | |
| CCatch::Generators::Generators< T > | |
| CCatch::Generators::IteratorGenerator< T > | |
| CCatch::Generators::IteratorGenerator< T > | |
| CCatch::Generators::MapGenerator< T, U, Func > | |
| CCatch::Generators::MapGenerator< T, U, Func > | |
| CCatch::Generators::RangeGenerator< T > | |
| CCatch::Generators::RangeGenerator< T > | |
| CCatch::Generators::RepeatGenerator< T > | |
| CCatch::Generators::RepeatGenerator< T > | |
| CCatch::Generators::SingleValueGenerator< T > | |
| CCatch::Generators::SingleValueGenerator< T > | |
| CCatch::Generators::TakeGenerator< T > | |
| CCatch::Generators::TakeGenerator< T > | |
| CCatch::Generators::IGenerator< T > | |
| CCatch::Generators::GeneratorWrapper< T > | |
| CCatch::Generators::GeneratorWrapper< U > | |
| Ckblib::get_manip< F > | A helper class for wrapping stream manipulators |
| Ckblib::has_member_swap< T > | |
| Chas_padding | |
| ►Chash | |
| Cstd::hash< kblib::delayed_construct< T > > | |
| Ckblib::heap_value< T > | |
| Ckblib::heap_value< held_type > | |
| ►CCatch::IContext | |
| CCatch::IMutableContext | |
| CCatch::IMutableContext | |
| Ckblib::identity | The identity function, as a function object |
| CCatch::IExceptionTranslator | |
| CCatch::IExceptionTranslatorRegistry | |
| CCatch::IGeneratorTracker | |
| Ckblib::ignore< typename, T > | Ignores its first template argument entirely, and returns its second |
| CCatch::IMutableEnumValuesRegistry | |
| CCatch::IMutableRegistryHub | |
| Ckblib::in_place_agg_t | |
| Ckblib::fakestd::in_place_t | |
| Ckblib::incrementer | A struct which increments anything it is added to. Suitable for use as a Delta type for range_t |
| Ckblib::indirect_range< Iter1, Iter2 > | Allow range-for iteration of an iterator pair |
| ►Cintegral_constant | |
| Ckblib::fakestd::is_nothrow_swappable_with< Tp, Up > | |
| ►Cstd::integral_constant | |
| Ckblib::constant< T, V > | |
| Ckblib::contains_types< Tuple, std::tuple< T, Ts... > > | |
| Ckblib::detail_poly::extract_derived_size< T, typename > | |
| Ckblib::detail_poly::extract_derived_size< T, void_if_t<(T::max_derived_size > sizeof(T))> > | |
| Ckblib::fakestd::detail::is_referenceable< Tp > | |
| Ckblib::fakestd::is_invocable< Fn, Args > | |
| Ckblib::fakestd::is_invocable_r< Ret, Fn, Args > | |
| Ckblib::fakestd::is_nothrow_invocable< Fn, Args > | |
| Ckblib::fakestd::is_nothrow_invocable_r< Ret, Fn, Args > | |
| Ckblib::fakestd::is_nothrow_swappable< Tp > | |
| Ckblib::fakestd::is_swappable< Tp > | |
| Ckblib::fakestd::is_swappable_with< Tp, Up > | |
| Ckblib::fnv::fnv_offset< std::uint32_t > | |
| Ckblib::fnv::fnv_offset< std::uint64_t > | |
| Ckblib::fnv::fnv_prime< std::uint32_t > | |
| Ckblib::fnv::fnv_prime< std::uint64_t > | |
| Ckblib::implies< A, B > | A metafunction for logical implication. That is, if A, then B. If not A, B is unimportant |
| Ckblib::implies< true, false > | Logical implication is only not satisfied by true -> false |
| Ckblib::padding_bits< T > | |
| Ckblib::state_size< std::linear_congruential_engine< UIntType, a, c, m > > | |
| Ckblib::state_size< std::mersenne_twister_engine< UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f > > | |
| Ckblib::state_size< std::subtract_with_carry_engine< UIntType, w, s, r > > | |
| Cstd::tuple_size< kblib::punner< Types... > > | |
| Cstd::tuple_size<::kblib::construct_with_size< C, Size > > | |
| Cstd::tuple_size<::kblib::enumeration< T > > | |
| Ckblib::intrusive_dual_map< Value, KeyExtract1, KeyExtract2, Hash1, Hash2, KeyEqual1, KeyEqual2 > | |
| Ckblib::intrusive_hash_map< Value, KeyExtract, Hash, KeyEqual > | |
| Ckblib::fakestd::detail::invokable_r< Ret, Fp, Args > | |
| Ckblib::fakestd::detail::invoke_result< AlwaysVoid, typename,... > | |
| Ckblib::fakestd::detail::invoke_result< decltype(void(invoke(std::declval< F >(), std::declval< Args >()...))), F, Args... > | |
| ►Ckblib::fakestd::detail::invoke_result< void, F, ArgTypes... > | |
| Ckblib::fakestd::invoke_result< F, ArgTypes > | |
| Ckblib::irange_t< Value, Delta > | |
| CCatch::IRegistryHub | |
| CCatch::IResultCapture | |
| CCatch::IRunner | |
| CCatch::is_callable< T > | |
| CCatch::is_callable_tester | |
| Ckblib::fakestd::detail::is_referenceable_impl | |
| Ckblib::is_space | |
| CCatch::Detail::IsStreamInsertable< T > | |
| CCatch::IStream | |
| Ckblib::detail_cry::value_and_index_impl< Range >::iterator | |
| Ckblib::range_t< Value, Delta >::iterator | A helper struct which acts as an iterator for the range elements, as they are generated on the fly |
| ►Ckblib::iterator_extractor< Container > | |
| Ckblib::indexer_extractor< Container > | |
| ►Cboost::iterator_facade | |
| Ckblib::multi_impl::mulspan_iterator< T > | |
| Ckblib::compact_bit_trie< Key, key_range, Value >::iterator_t< V > | |
| Ckblib::iterator_type_for< Range, typename > | Type trait that determines the iterator type for a range |
| Ckblib::iterator_type_for< Range, void_t< decltype(begin(std::declval< Range & >()))> > | |
| Ckblib::iterator_type_for< T[N], void > | |
| CCatch::ITestCaseRegistry | |
| ►CCatch::ITestInvoker | |
| CCatch::TestInvokerAsMethod< C > | |
| CCatch::TestInvokerAsMethod< C > | |
| ►CCatch::ITransientExpression | |
| CCatch::BinaryExpr< LhsT, RhsT > | |
| CCatch::BinaryExpr< LhsT, RhsT > | |
| CCatch::MatchExpr< ArgT, MatcherT > | |
| CCatch::MatchExpr< ArgT, MatcherT > | |
| CCatch::UnaryExpr< LhsT > | |
| CCatch::UnaryExpr< LhsT > | |
| Ck | |
| Ckblib::detail_poly::kblib_erased_hash_t< T, hash > | |
| Ckblib::detail_poly::kblib_erased_hash_t< T, void_t< fakestd::invoke_result_t< std::hash< T >, T > > > | |
| Ckblib::compact_bit_trie< Key, key_range, Value >::key_type | |
| Ckblib::key_type_setlike< Container, bool, bool > | |
| CCatch::LazyExpression | |
| Ckblib::lexical_caster< To, From > | |
| Ckblib::lexical_caster< Same, Same > | |
| Ckblib::lexical_caster< std::string, From > | |
| Ckblib::lexical_caster< std::string, std::string > | |
| Ckblib::lexical_caster< std::string_view, From > | |
| Ckblib::lexical_caster< std::string_view, std::string > | |
| Ckblib::lexical_caster< std::string_view, std::string_view > | |
| Ckblib::lexical_caster< To, std::string > | |
| Ckblib::lexical_caster< To, std::string_view > | |
| Ckblib::list_as_tuple< T > | |
| Ckblib::list_as_tuple< Tuple< Ts... > > | |
| Ckblib::detail_memory::live_ptr_base< D > | |
| ►Ckblib::detail_memory::live_ptr_base< live_ptr< const mT > > | |
| Ckblib::live_ptr< const mT > | |
| ►Ckblib::detail_memory::live_ptr_base< live_ptr< T > > | |
| Ckblib::live_ptr< T > | |
| ►Ckblib::live_wrapper< T > | |
| Ckblib::live_wrapper< const T > | |
| Ckblib::live_wrapper< mT > | |
| Ckblib::fakestd::make_void< Ts > | |
| CCatch::Matchers::Impl::MatcherMethod< ObjectT > | |
| ►CCatch::Matchers::Impl::MatcherMethod< ArgT > | |
| ►CCatch::Matchers::Impl::MatcherBase< ArgT > | |
| CCatch::Matchers::Impl::MatchAllOf< ArgT > | |
| CCatch::Matchers::Impl::MatchAllOf< ArgT > | |
| CCatch::Matchers::Impl::MatchAnyOf< ArgT > | |
| CCatch::Matchers::Impl::MatchAnyOf< ArgT > | |
| CCatch::Matchers::Impl::MatchNotOf< ArgT > | |
| CCatch::Matchers::Impl::MatchNotOf< ArgT > | |
| CCatch::Matchers::Impl::MatcherBase< ArgT > | |
| ►CCatch::Matchers::Impl::MatcherMethod< double > | |
| CCatch::Matchers::Impl::MatcherBase< double > | |
| CCatch::Matchers::Impl::MatcherBase< double > | |
| ►CCatch::Matchers::Impl::MatcherMethod< std::exception > | |
| CCatch::Matchers::Impl::MatcherBase< std::exception > | |
| CCatch::Matchers::Impl::MatcherBase< std::exception > | |
| ►CCatch::Matchers::Impl::MatcherMethod< std::string > | |
| CCatch::Matchers::Impl::MatcherBase< std::string > | |
| CCatch::Matchers::Impl::MatcherBase< std::string > | |
| ►CCatch::Matchers::Impl::MatcherMethod< std::vector< T, Alloc > > | |
| CCatch::Matchers::Impl::MatcherBase< std::vector< T, Alloc > > | |
| CCatch::Matchers::Impl::MatcherBase< std::vector< T, Alloc > > | |
| ►CCatch::Matchers::Impl::MatcherMethod< std::vector< T, AllocMatch > > | |
| CCatch::Matchers::Impl::MatcherBase< std::vector< T, AllocMatch > > | |
| CCatch::Matchers::Impl::MatcherBase< std::vector< T, AllocMatch > > | |
| ►CCatch::Matchers::Impl::MatcherMethod< T > | |
| ►CCatch::Matchers::Impl::MatcherBase< T > | |
| CCatch::Matchers::Exception::ExceptionMessageMatcher | |
| CCatch::Matchers::Exception::ExceptionMessageMatcher | |
| CCatch::Matchers::Floating::WithinAbsMatcher | |
| CCatch::Matchers::Floating::WithinAbsMatcher | |
| CCatch::Matchers::Floating::WithinRelMatcher | |
| CCatch::Matchers::Floating::WithinRelMatcher | |
| CCatch::Matchers::Floating::WithinUlpsMatcher | |
| CCatch::Matchers::Floating::WithinUlpsMatcher | |
| CCatch::Matchers::Generic::PredicateMatcher< T > | |
| CCatch::Matchers::Generic::PredicateMatcher< T > | |
| CCatch::Matchers::StdString::RegexMatcher | |
| CCatch::Matchers::StdString::RegexMatcher | |
| ►CCatch::Matchers::StdString::StringMatcherBase | |
| CCatch::Matchers::StdString::ContainsMatcher | |
| CCatch::Matchers::StdString::ContainsMatcher | |
| CCatch::Matchers::StdString::EndsWithMatcher | |
| CCatch::Matchers::StdString::EndsWithMatcher | |
| CCatch::Matchers::StdString::EqualsMatcher | |
| CCatch::Matchers::StdString::EqualsMatcher | |
| CCatch::Matchers::StdString::StartsWithMatcher | |
| CCatch::Matchers::StdString::StartsWithMatcher | |
| CCatch::Matchers::StdString::StringMatcherBase | |
| CCatch::Matchers::Vector::ApproxMatcher< T, AllocComp, AllocMatch > | |
| CCatch::Matchers::Vector::ApproxMatcher< T, AllocComp, AllocMatch > | |
| CCatch::Matchers::Vector::ContainsElementMatcher< T, Alloc > | |
| CCatch::Matchers::Vector::ContainsElementMatcher< T, Alloc > | |
| CCatch::Matchers::Vector::ContainsMatcher< T, AllocComp, AllocMatch > | |
| CCatch::Matchers::Vector::ContainsMatcher< T, AllocComp, AllocMatch > | |
| CCatch::Matchers::Vector::EqualsMatcher< T, AllocComp, AllocMatch > | |
| CCatch::Matchers::Vector::EqualsMatcher< T, AllocComp, AllocMatch > | |
| CCatch::Matchers::Vector::UnorderedEqualsMatcher< T, AllocComp, AllocMatch > | |
| CCatch::Matchers::Vector::UnorderedEqualsMatcher< T, AllocComp, AllocMatch > | |
| CCatch::Matchers::Impl::MatcherBase< T > | |
| ►CCatch::Matchers::Impl::MatcherUntypedBase | |
| CCatch::Matchers::Impl::MatcherBase< std::exception > | |
| CCatch::Matchers::Impl::MatcherBase< double > | |
| CCatch::Matchers::Impl::MatcherBase< ArgT > | |
| CCatch::Matchers::Impl::MatcherBase< std::string > | |
| CCatch::Matchers::Impl::MatcherBase< std::vector< T, AllocMatch > > | |
| CCatch::Matchers::Impl::MatcherBase< std::vector< T, Alloc > > | |
| CCatch::Matchers::Impl::MatcherBase< std::exception > | |
| CCatch::Matchers::Impl::MatcherBase< double > | |
| CCatch::Matchers::Impl::MatcherBase< ArgT > | |
| CCatch::Matchers::Impl::MatcherBase< std::string > | |
| CCatch::Matchers::Impl::MatcherBase< std::vector< T, AllocMatch > > | |
| CCatch::Matchers::Impl::MatcherBase< std::vector< T, Alloc > > | |
| CCatch::Matchers::Impl::MatcherBase< T > | |
| CCatch::Matchers::Impl::MatcherBase< T > | |
| Ckblib::max_t | Shorthand for std::numeric_limits::max() |
| Ckblib::nums::max_t | Shorthand for std::numeric_limits::max() |
| Ckblib::member_of< T > | |
| Ckblib::member_of< M T::* > | |
| CCatch::MessageInfo | |
| ►CCatch::MessageStream | |
| CCatch::MessageBuilder | |
| CCatch::MessageBuilder | |
| Ckblib::meta_type< Ts > | |
| ►Ckblib::meta_type< const T & > | |
| Ckblib::copy_const< C, T &, true > | |
| ►Ckblib::meta_type< const T && > | |
| Ckblib::copy_const< C, T &&, true > | |
| ►Ckblib::meta_type< const T > | |
| Ckblib::copy_const< C, T, true > | |
| ►Ckblib::meta_type< Container::key_type > | |
| Ckblib::key_type_setlike< Container, true, false > | |
| ►Ckblib::meta_type< Container::value_type > | |
| Ckblib::value_type_linear< Container, false, typename Container::value_type > | |
| ►Ckblib::meta_type< R > | |
| Ckblib::return_type< R(Args...) const > | |
| Ckblib::return_type< R(Args...) const volatile > | |
| Ckblib::return_type< R(Args...) volatile > | |
| Ckblib::return_type< R(Args...)> | |
| ►Ckblib::meta_type< T > | |
| Ckblib::copy_const< C, T, bool > | |
| Ckblib::return_assert< true, T > | |
| ►Ckblib::meta_type< void > | |
| Ckblib::void_if< true > | |
| Ckblib::min_t | Shorthand for std::numeric_limits::min() |
| Ckblib::nums::min_t | Shorthand for std::numeric_limits::min() |
| ►CTraits::move_t | |
| Ckblib::detail_poly::erased_construct< poly_obj_traits< Obj > > | |
| Ckblib::detail_poly::erased_construct< Traits > | |
| Ckblib::multi_range< Iter1, EndIter, count > | |
| Ckblib::multi_range< Iter1, EndIter, 0 > | |
| Ckblib::multi_span< T > | |
| CCatch::NameAndTags | |
| Ckblib::fakestd::detail::nat | |
| Ckblib::detail_units::nearest_ratio< Num, Den > | |
| Ckblib::detail::next_larger_signed< T > | |
| Ckblib::detail::no_dangle< T > | |
| Ckblib::detail::no_dangle< T && > | |
| Cno_hash | |
| Cno_padding | |
| Ckblib::detail::node< Elem, Value > | |
| ►CCatch::NonCopyable | |
| CCatch::AutoReg | |
| CCatch::AutoReg | |
| CCatch::IConfig | |
| CCatch::IConfig | |
| CCatch::ReusableStringStream | |
| CCatch::ReusableStringStream | |
| CCatch::Section | |
| CCatch::Section | |
| Ckblib::detail_memory::noop_t | |
| Ckblib::fakestd::detail::not_fn_t< F > | |
| Ckblib::fakestd::detail::nothrow_invokable_r_imp< IsInvokable, IsCVVoid, Ret, Fp, Args > | |
| Ckblib::fakestd::detail::nothrow_invokable_r_imp< true, false, Ret, Fp, Args... > | |
| Ckblib::fakestd::detail::nothrow_invokable_r_imp< true, true, Ret, Fp, Args... > | |
| Ckblib::fakestd::detail::nothrow_swappable_with< Tp, Up, Swappable > | |
| Ckblib::null_construct< T, bool > | |
| Ckblib::null_construct< kblib::detail_memory::on_destroy< std::vector< kblib::live_wrapper ** >, kblib::live_wrapper::_destroy > > | |
| CCatch::Option< T > | |
| CCatch::pluralise | |
| Ckblib::detail::pointer< D, T, typename > | |
| Ckblib::detail::pointer< D, T, void_t< typename D::pointer > > | |
| Ckblib::poly_obj_traits< Obj, CType > | 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 |
| Ckblib::detail_units::prefix | |
| Cprint< T > | |
| Ckblib::counting_back_insert_iterator< Container >::proxy_iterator | |
| Ckblib::detail_bits::pun_el< P, Type, S, size_t, aliases > | |
| Ckblib::detail_bits::pun_el< P, Type[], S, I, true > | |
| Ckblib::detail_bits::pun_el< P, Type[S], S, I, true > | |
| ►Ckblib::detail_bits::pun_el< punner_impl< S, std::index_sequence< Is... >, Types... >, Types, S, Is > | |
| Ckblib::detail_bits::punner_impl< S, std::index_sequence< Is... >, Types... > | |
| Ckblib::detail_bits::pun_proxy< Type, Storage > | |
| Cpunner | |
| Ckblib::detail_bits::punner_impl< S, I_S, Types > | |
| ►Ckblib::detail_bits::punner_impl< detail_bits::max_size< Types... >, std::index_sequence_for< Types... >, Types... > | |
| Ckblib::punner< Types > | |
| Ckblib::RAII_wrapper< T > | |
| Ckblib::range_t< Value, Delta > | A range generator, similar to Python 3's range() |
| CRef< Args > | |
| CCatch::RegistrarForTagAliases | |
| CCatch::ResultDisposition | |
| CCatch::ResultWas | |
| Cbuffer::ret_proxy | |
| Ckblib::return_assert< V, T > | 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 |
| Ckblib::return_type< F > | |
| CCatch::RunTests | |
| Ckblib::safe_signed< N, typename > | |
| Ckblib::safe_signed< N, std::enable_if_t< std::is_integral< N >::value, void > > | |
| CCatch::ScopedMessage | |
| CCatch::SectionEndInfo | |
| CCatch::SectionInfo | |
| Ckblib::shift_mask< UIntType, shift, mask > | |
| CCatch::ShowDurations | |
| Ckblib::detail_simple::simple_range< T > | |
| CCatch::SimplePcg32 | |
| Ckblib::detail_sort::sort_transform_impl< RandomAccessIt, UnaryOperation, BinaryPredicate, SortKey, small_size, bool, bool, bool, bool > | Sort data after applying an arbitrary transformation to it. The primary template handles the general case of arbitrary transformation and arbitrary compare predicate |
| Ckblib::detail_sort::sort_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()) |
| Ckblib::detail_sort::sort_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 |
| Ckblib::detail_sort::sort_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 |
| Ckblib::detail_sort::sort_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 |
| Ckblib::detail_sort::sort_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 |
| Ckblib::detail_sort::sort_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 |
| Ckblib::detail_sort::sort_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 |
| CCatch::SourceLineInfo | |
| Ckblib::sparse_trie_map< Key, Value, Extractor > | |
| Ckblib::sparse_trie_set< Key, Extractor > | |
| Ckblib::stack< T, Container > | |
| Ckblib::state_size< T > | |
| ►Ckblib::state_size< Engine > | |
| Ckblib::state_size< std::discard_block_engine< Engine, P, R > > | |
| Ckblib::state_size< std::independent_bits_engine< Engine, W, UIntType > > | |
| Ckblib::state_size< std::shuffle_order_engine< Engine, K > > | |
| Ckblib::state_size< transform_engine< Engine, Transform > > | |
| Ckblib::detail_direct_map::storage_for< T, true > | |
| Ckblib::detail::str_type< T, typename > | Converts types to strings |
| Ckblib::detail::str_type< char, char > | Override for char to avoid conversion to integer |
| Ckblib::detail::str_type< char16_t, char16_t > | Override for char16_t to avoid conversion to integer |
| Ckblib::detail::str_type< char32_t, char32_t > | Override for char32_t to avoid conversion to integer |
| Ckblib::detail::str_type< T, void > | Performs a natural conversion to a stringlike type |
| Ckblib::detail::str_type< wchar_t, wchar_t > | Override for wchar_t to avoid conversion to integer |
| CCatch::StreamEndStop | |
| CCatch::StringMaker< T, typename > | |
| CCatch::StringMaker< bool > | |
| CCatch::StringMaker< Catch::Detail::Approx > | |
| CCatch::StringMaker< char * > | |
| CCatch::StringMaker< char > | |
| CCatch::StringMaker< char const * > | |
| CCatch::StringMaker< char[SZ]> | |
| CCatch::StringMaker< double > | |
| CCatch::StringMaker< float > | |
| CCatch::StringMaker< int > | |
| CCatch::StringMaker< long > | |
| CCatch::StringMaker< long long > | |
| CCatch::StringMaker< R C::* > | |
| CCatch::StringMaker< R, typename std::enable_if< is_range< R >::value &&!::Catch::Detail::IsStreamInsertable< R >::value >::type > | |
| CCatch::StringMaker< signed char > | |
| CCatch::StringMaker< signed char[SZ]> | |
| CCatch::StringMaker< std::nullptr_t > | |
| CCatch::StringMaker< std::string > | |
| CCatch::StringMaker< std::wstring > | |
| CCatch::StringMaker< T * > | |
| CCatch::StringMaker< T[SZ]> | |
| CCatch::StringMaker< unsigned char > | |
| CCatch::StringMaker< unsigned char[SZ]> | |
| CCatch::StringMaker< unsigned int > | |
| CCatch::StringMaker< unsigned long > | |
| CCatch::StringMaker< unsigned long long > | |
| CCatch::StringMaker< wchar_t * > | |
| CCatch::StringMaker< wchar_t const * > | |
| CCatch::StringRef | |
| Ckblib::fakestd::detail::swappable_with< Tp, Up, NotVoid > | |
| ►CT | |
| Ckblib::detail_memory::as_base_class< T, true, true > | |
| Ckblib::null_construct< T, true > | |
| ►Ckblib::detail::tag< T > | |
| Ckblib::first_bigger_than< size, T, Ts > | |
| Ckblib::first_bigger_than< size, T > | |
| Ckblib::poly_obj< Obj, Capacity, Traits >::tag< U, aggregate > | |
| Ctag< Is > | |
| Ckblib::detail_memory::template_param< T > | |
| Ckblib::detail_memory::template_param< C< T > > | |
| ►Cdecltypeis_callable_tester::test | |
| CCatch::is_callable< Fun(Args...)> | |
| CCatch::is_callable< Fun(Args...)> | |
| ►CCatch::TestCaseInfo | |
| CCatch::TestCase | |
| CCatch::TestCase | |
| CCatch::TestFailureException | |
| CCatch::Timer | |
| Ckblib::to_pointer_impl< ptr > | |
| Ckblib::to_pointer_impl< T * > | |
| CCatch::Totals | |
| Ckblib::transform_iterator< base_iterator, operation > | An InputIterator that applies a transformation to the elements of the range |
| Ckblib::trie< Key, T, Extractor, bool > | |
| Ckblib::trie< KeyElem, T, Extractor, false > | |
| Ckblib::trie< KeyElem[], T, Extractor, false > | |
| Ckblib::trie_map< Key, Value, Extractor, offset_type, SequenceContainer > | |
| Ckblib::detail_bits::trie_node< Key, Value > | |
| Ckblib::trie_qmap< Key, Value, Extractor, offset_type, SequenceContainer > | |
| Ckblib::trie_qset< Key, Extractor, offset_type > | |
| Ckblib::trie_set< Key, Extractor, offset_type > | |
| Ckblib::trivial_array< T, N > | Std::array isn't constexpr enough in C++14, so a dedicated array class is needed for constexpr functions |
| Ckblib::trivial_pair< T > | 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() |
| Ckblib::trivial_seed_seq | |
| ►Cstd::true_type | |
| CCatch::detail::is_range_impl< T, typename void_type< decltype(begin(std::declval< T >()))>::type > | |
| CCatch::detail::is_range_impl< T, typename void_type< decltype(begin(std::declval< T >()))>::type > | |
| CCatch::true_given< typename > | |
| CCatch::true_given< typename > | |
| Ckblib::contains_type< std::tuple< T, Ts... >, T > | |
| Ckblib::contains_types< Tuple, std::tuple<> > | |
| Ckblib::detail_iterators::is_addable< T, U, void_t< decltype(std::declval< T & >()+std::declval< U & >())> > | |
| Ckblib::detail_units::is_si_ratio< std::atto > | |
| Ckblib::detail_units::is_si_ratio< std::centi > | |
| Ckblib::detail_units::is_si_ratio< std::deca > | |
| Ckblib::detail_units::is_si_ratio< std::deci > | |
| Ckblib::detail_units::is_si_ratio< std::exa > | |
| Ckblib::detail_units::is_si_ratio< std::femto > | |
| Ckblib::detail_units::is_si_ratio< std::giga > | |
| Ckblib::detail_units::is_si_ratio< std::hecto > | |
| Ckblib::detail_units::is_si_ratio< std::kilo > | |
| Ckblib::detail_units::is_si_ratio< std::mega > | |
| Ckblib::detail_units::is_si_ratio< std::micro > | |
| Ckblib::detail_units::is_si_ratio< std::milli > | |
| Ckblib::detail_units::is_si_ratio< std::nano > | |
| Ckblib::detail_units::is_si_ratio< std::peta > | |
| Ckblib::detail_units::is_si_ratio< std::pico > | |
| Ckblib::detail_units::is_si_ratio< std::ratio< 1 > > | |
| Ckblib::detail_units::is_si_ratio< std::tera > | |
| Ckblib::exists< T > | |
| Ckblib::hash_detected< T, void_t< typename T::hasher > > | |
| Ckblib::is_aliasing_type< char > | |
| Ckblib::is_aliasing_type< unsigned char > | |
| Ckblib::is_bidirectional_iterator< T, void_if_t< std::is_base_of< std::bidirectional_iterator_tag, typename std::iterator_traits< T >::iterator_category >::value > > | |
| Ckblib::is_bounded_array< T[N]> | |
| Ckblib::is_forward_iterator< T, void_if_t< std::is_base_of< std::forward_iterator_tag, typename std::iterator_traits< T >::iterator_category >::value > > | |
| Ckblib::is_hashable< Key, void_if_t< std::is_constructible< FNV_hash< Key > >::value > > | |
| Ckblib::is_input_iterator< T, void_if_t< std::is_base_of< std::input_iterator_tag, typename std::iterator_traits< T >::iterator_category >::value > > | |
| Ckblib::is_iterable< Range, void_if_t< is_input_iterator< decltype(begin(std::declval< Range & >()))>::value > > | |
| Ckblib::is_iterable< T(&)[N], void > | |
| Ckblib::is_iterable< T[N], void > | |
| Ckblib::is_iterator< T, void_t< decltype(*std::declval< T & >(), void(),++std::declval< T & >())> > | |
| Ckblib::is_optional< std::optional< U > > | |
| Ckblib::is_output_iterator_for< T, E, void_t< decltype(*std::declval< T & >()++=std::declval< const E & >())> > | |
| Ckblib::is_radix_sortable< T, void_if_t< is_linear_container_v< T > and std::is_integral< typename T::value_type >::value > > | |
| Ckblib::is_radix_sortable< T, void_if_t< std::is_enum< T >::value > > | |
| Ckblib::is_radix_sortable< T, void_if_t< std::is_integral< T >::value > > | |
| Ckblib::is_radix_sortable< std::bitset< B >, void > | |
| Ckblib::is_random_access_iterator< T, void_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< T >::iterator_category >::value > > | |
| Ckblib::is_trivial_transformation< identity > | |
| Ckblib::is_tuple_like< T, void_t< typename std::tuple_element< 0, T >::type > > | |
| Ckblib::is_unbounded_array< T[]> | |
| Ckblib::key_detected< T, void_t< typename T::key_type > > | |
| Ckblib::mapped_detected< T, void_t< typename T::mapped_type > > | |
| Ckblib::metafunction_success< T, void_t< typename T::type > > | |
| Ckblib::unicode_widen< char16_t, char32_t > | |
| Ckblib::value_detected< T, void_t< typename T::value_type > > | |
| Cstd::tuple_element< 0, ::kblib::enumeration< T > > | |
| Cstd::tuple_element< 0, const volatile ::kblib::enumeration< T > > | |
| Cstd::tuple_element< 0, kblib::detail_cry::value_index_pair< T > > | |
| Cstd::tuple_element< 0, volatile ::kblib::enumeration< T > > | |
| Cstd::tuple_element< 1, ::kblib::enumeration< T > > | Copies decay away the const |
| Cstd::tuple_element< 1, const ::kblib::enumeration< T > > | Unless const is explicitly added |
| Cstd::tuple_element< 1, const volatile ::kblib::enumeration< T > > | But you can also add const to a reference |
| Cstd::tuple_element< 1, kblib::detail_cry::value_index_pair< T > > | |
| Cstd::tuple_element< 1, volatile ::kblib::enumeration< T > > | References keep the same qualifications as the original |
| Cstd::tuple_element< I, kblib::punner< Types... > > | |
| Cstd::tuple_size< kblib::detail_cry::value_index_pair< T > > | |
| Ckblib::detail::tuple_type< T > | Given a std::variant T, provides the member type which is a tuple of the same types |
| Ckblib::detail::tuple_type< std::variant< Ts... > > | Given a std::variant T, provides the member type which is a tuple of the same types |
| Ckblib::fakestd::detail::two | |
| ►Cconditional::type | |
| Ckblib::fakestd::is_nothrow_swappable< Tp > | |
| ►Cstd::conditional::type | |
| Ckblib::fakestd::is_swappable< Tp > | |
| ►Ctypename first_bigger_than::type | |
| Ckblib::first_bigger_than< size, T, Ts > | |
| Ckblib::type_constant< T, V > | |
| Ckblib::detail::type_list< Args > | |
| Ckblib::detail::type_map< Key, Comp, Vals > | |
| Ckblib::detail::type_map_el< K, V > | |
| Ckblib::union_pun< Type, Storage > | |
| Ckblib::union_pun< char16_t[sizeof(char *)/2], &punner::storage > | |
| Ckblib::union_pun< const char *, &punner::storage > | |
| Ckblib::union_pun< std::uintptr_t, &punner::storage > | |
| Ckblib::union_pun< Type[N], Storage > | |
| ►Cstd::unique_ptr | |
| Ckblib::heap_value2< T, D > | |
| Ckblib::heap_value2< T[], D > | |
| Ckblib::detail_units::unit_conversion< M > | |
| ►CURBG | |
| Ckblib::transform_engine< URBG, Transform > | |
| CCatch::UseColour | |
| Ckblib::detail::value< I, T > | |
| ►Ckblib::detail::value< Idxs, Ts > | |
| Ckblib::detail::values< std::index_sequence< Idxs... >, Ts... > | |
| ►Ckblib::detail_cry::value_and_index_base< Range, typename > | |
| Ckblib::detail_cry::value_and_index_impl< Range > | |
| Ckblib::detail_cry::value_and_index_base< Range, std::enable_if_t< not std::is_reference_v< Range > > > | |
| Ckblib::detail_cry::value_index_pair< Iterator > | |
| Ckblib::detail_cry::value_index_pair< iterator_type > | |
| Ckblib::detail_memory::value_init | |
| Ckblib::value_type_linear< Container, bool, T > | |
| Ckblib::detail::values< Idxs, Ts > | |
| ►Cvoid | |
| Ckblib::first_bigger_than< size, T > | |
| Ckblib::void_if< bool > | |
| CCatch::detail::void_type<... > | |
| CCatch::WaitForKeypress | |
| CCatch::WarnAbout | |
| Ckblib::zip_iterator< InputIt1, EndIt, InputIt2 > | |
| Ckblib::zip_iterator< It1, It1, It2 > | |
| ►Ckblib::Ts | |
| Ckblib::visitor< Ts > | Helper class for std::visiting a std::variant |
1.9.4