| Cktl::binary_heap< T, Comp, Alloc > | A priority queue implemented as a binary heap |
| ▼Cstd::bool_constant | |
| 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::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_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::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::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, Bits, 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::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::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 |
1.9.1