Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123]

▼Nktl
▼Ndetail
Cfallback_builder
Cfallback_builder< R, std::tuple< Alloc > >
Cfallback_builder< R, std::tuple< Ts... > >
Cget_size_type
Cget_size_type< Alloc, std::void_t< typename Alloc::size_type > >
Chas_construct
Chas_construct< std::void_t< decltype(std::declval< Alloc & >().construct(std::declval< Args >()...))>, Alloc, Args... >
Chas_destroy
Chas_destroy< Alloc, Ptr, std::void_t< decltype(std::declval< Alloc & >().destroy(std::declval< Ptr >()))> >
Chas_max_size
Chas_max_size< Alloc, std::void_t< decltype(std::declval< Alloc & >().max_size())> >
Chas_no_value_type
Chas_no_value_type< Alloc, std::void_t< typename Alloc::value_type > >
Chas_nothrow_allocate
Chas_nothrow_allocate< Alloc, false >
Chas_nothrow_allocate< Alloc, true >
Chas_nothrow_construct
Chas_nothrow_construct< std::enable_if_t< has_construct_v< Alloc, Args... > >, Alloc, Args... >
Chas_nothrow_destroy
Chas_nothrow_destroy< Alloc, Ptr, std::enable_if_t< has_destroy_v< Alloc, Ptr > > >
Chas_nothrow_max_size
Chas_nothrow_max_size< Alloc, std::enable_if_t< has_max_size_v< Alloc > > >
Chas_nothrow_owns
Chas_nothrow_owns< Alloc, std::enable_if_t< has_owns_v< Alloc > > >
Chas_owns
Chas_owns< Alloc, std::void_t< decltype(std::declval< Alloc & >().owns(std::declval< void * >()))> >
Chas_plain_allocate
Chas_plain_allocate< Alloc, std::void_t< decltype(std::declval< Alloc & >().allocate(std::declval< size_t >()))> >
Cis_decrementable
Cis_decrementable< T, std::void_t< decltype(--std::declval< T & >())> >
Cis_function_pointer
Cis_function_pointer< R()(Ts...), std::void_t< R()(Ts...)> >
Cis_iterable
Cis_iterable< T, std::void_t< decltype(std::begin(std::declval< T & >())), decltype(std::end(std::declval< T & >()))> >
Cpow2
Csegragator_builder
Csegragator_builder< R, std::tuple< Alloc > >
Csegragator_builder< R, std::tuple< Ts... > >
Csize_invert
Csize_invert< false, N, M >
Csize_invert< true, N, M >
Ctuple_split_indices
Ctuple_split_indices< O, std::index_sequence< N... >, std::index_sequence< M... >, std::tuple< T... > >
Cunderlying_type
Cunderlying_type< T, std::enable_if_t< std::is_enum_v< T > > >
Cunderlying_type< T, std::enable_if_t< std::is_pointer_v< T > &&!is_function_pointer_v< T > > >
Cbinary_heap	A priority queue implemented as a binary heap
Ccascading	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
Cdebug
Cfallback	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
Cfreelist	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
Cglobal
Cipair_iterable	Wraps an iterable object for use with indexed iterators
Cipair_iterator	Wraps an iterator to return an index along with the value
Cipair_value	Pair of an index and value from an iterator
Clinear_allocator	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
Cmallocator	An allocator which uses an aligned malloc for allocation
Cnotomic
Cnull_allocator	An allocator which does nothing. Useful for debugging composite allocators, like ensuring a specific path in a composite allocator is not used
Coverflow
Cpacked_ptr	A packed pointer-like type which takes advantage of any bits that don't get used due to alignment
Creference
Csegragator	An allocator which delegates allocations between 2 different allocators based on a size threshold
Cshared
Csource_location
Cstack	A stack object of a given `Size`
Cstack_allocator	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
Cthreaded
Ctrivial_array	A dynamically alloacted array of trivial types
Ctrivial_buffer
Ctrivial_vector	A dynamically allocated vector or trivial types
▼Ctype_allocator	Wrapper class for making an untyped allocator into a typed allocator
Crebind