This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12]

Cktl::binary_heap< T, Comp, Alloc >	A priority queue implemented as a binary heap
▼Cstd::bool_constant
Cktl::detail::has_nothrow_allocate< Alloc, false >
Cktl::detail::has_nothrow_allocate< Alloc, true >
Cktl::detail::has_nothrow_construct< std::enable_if_t< has_construct_v< Alloc, Args... > >, Alloc, Args... >
Cktl::detail::has_nothrow_destroy< Alloc, Ptr, std::enable_if_t< has_destroy_v< Alloc, Ptr > > >
Cktl::detail::has_nothrow_max_size< Alloc, std::enable_if_t< has_max_size_v< Alloc > > >
Cktl::detail::has_nothrow_owns< Alloc, std::enable_if_t< has_owns_v< Alloc > > >
Cktl::cascading< Alloc >	An allocator which owns multiple instances of a given sub allocator. When allocating it will attempt to use the first available allocator. Upon failure it will instead create a new instance and allocate from it
Cktl::debug< Alloc, Container >
Cktl::fallback< P, F >	An allocator which delegates allocations between 2 different allocators. It first attempts to allocate with the primary allocator, but upon failure will use the fallback allocator
Cktl::detail::fallback_builder< bool, typename >
Cktl::detail::fallback_builder< R, std::tuple< Alloc > >
Cktl::detail::fallback_builder< R, std::tuple< Ts... > >
▼Cstd::false_type
Cktl::detail::has_construct< Void, Types >
Cktl::detail::has_destroy< Alloc, Ptr, typename >
Cktl::detail::has_max_size< Alloc, typename >
Cktl::detail::has_no_value_type< Alloc, std::void_t< typename Alloc::value_type > >
Cktl::detail::has_nothrow_allocate< Alloc, bool >
Cktl::detail::has_nothrow_construct< Void, Types >
Cktl::detail::has_nothrow_destroy< Alloc, Ptr, typename >
Cktl::detail::has_nothrow_max_size< Alloc, typename >
Cktl::detail::has_nothrow_owns< Alloc, typename >
Cktl::detail::has_owns< Alloc, typename >
Cktl::detail::has_plain_allocate< Alloc, typename >
Cktl::detail::is_decrementable< T, typename >
Cktl::detail::is_function_pointer< T, typename >
Cktl::detail::is_iterable< T, typename >
Cktl::freelist< Min, Max, Alloc >	An allocator which allocates using its underlying allocator. Only allocates if the requested size is within the `Min` and `Max` range When deallocating it chains the memory in a linked list, which can then be reused
Cktl::detail::get_size_type< Alloc, typename >
Cktl::detail::get_size_type< Alloc, std::void_t< typename Alloc::size_type > >
Cktl::global< Alloc >
Cktl::ipair_iterable< K, C >	Wraps an iterable object for use with indexed iterators
Cktl::ipair_iterator< K, I >	Wraps an iterator to return an index along with the value
Cktl::ipair_value< K, V >	Pair of an index and value from an iterator
Cktl::linear_allocator< Size >	A linear allocator which gives out chunks of its internal stack. Increments a counter during allocation, which makes it very fast but also unlikely to deallocate it again. Has a max allocation size of the `Size` given
Cktl::mallocator	An allocator which uses an aligned malloc for allocation
Cktl::notomic< T >
Cktl::null_allocator	An allocator which does nothing. Useful for debugging composite allocators, like ensuring a specific path in a composite allocator is not used
Cktl::overflow< Alloc, Stream >
Cktl::packed_ptr< PtrT, IntT, Min, Max, Alignment >	A packed pointer-like type which takes advantage of any bits that don't get used due to alignment
Cktl::detail::pow2< N >
Cktl::type_allocator< T, Alloc >::rebind< U >
Cktl::reference< Alloc >
Cktl::segragator< Threshold, P, F >	An allocator which delegates allocations between 2 different allocators based on a size threshold
Cktl::detail::segragator_builder< bool, typename >
Cktl::detail::segragator_builder< R, std::tuple< Alloc > >
Cktl::detail::segragator_builder< R, std::tuple< Ts... > >
Cktl::shared< Alloc, Atomic >
Cktl::detail::size_invert< bool, size_t, size_t >
Cktl::detail::size_invert< false, N, M >
Cktl::detail::size_invert< true, N, M >
Cktl::source_location
Cktl::stack< Size >	A stack object of a given `Size`
Cktl::stack_allocator< Size >	A linear allocator which gives out chunks of its allocated stack. Increments a counter during allocation, which makes it very fast but also unlikely to deallocate it again. Has a max allocation size of the `Size` given
Cktl::threaded< Alloc >
Cktl::trivial_array< T, Alloc >	A dynamically alloacted array of trivial types
Cktl::trivial_buffer< T, Size >
Cktl::trivial_vector< T, Alloc >	A dynamically allocated vector or trivial types
▼Cstd::true_type
Cktl::detail::has_construct< std::void_t< decltype(std::declval< Alloc & >().construct(std::declval< Args >()...))>, Alloc, Args... >
Cktl::detail::has_destroy< Alloc, Ptr, std::void_t< decltype(std::declval< Alloc & >().destroy(std::declval< Ptr >()))> >
Cktl::detail::has_max_size< Alloc, std::void_t< decltype(std::declval< Alloc & >().max_size())> >
Cktl::detail::has_no_value_type< Alloc, typename >
Cktl::detail::has_owns< Alloc, std::void_t< decltype(std::declval< Alloc & >().owns(std::declval< void * >()))> >
Cktl::detail::has_plain_allocate< Alloc, std::void_t< decltype(std::declval< Alloc & >().allocate(std::declval< size_t >()))> >
Cktl::detail::is_decrementable< T, std::void_t< decltype(--std::declval< T & >())> >
Cktl::detail::is_function_pointer< R()(Ts...), std::void_t< R()(Ts...)> >
Cktl::detail::is_iterable< T, std::void_t< decltype(std::begin(std::declval< T & >())), decltype(std::end(std::declval< T & >()))> >
Cktl::detail::tuple_split_indices< size_t, typename, typename, typename >
Cktl::detail::tuple_split_indices< O, std::index_sequence< N... >, std::index_sequence< M... >, std::tuple< T... > >
Cktl::type_allocator< T, Alloc >	Wrapper class for making an untyped allocator into a typed allocator
Cktl::detail::underlying_type< T, typename >
Cktl::detail::underlying_type< T, std::enable_if_t< std::is_enum_v< T > > >
Cktl::detail::underlying_type< T, std::enable_if_t< std::is_pointer_v< T > &&!is_function_pointer_v< T > > >