Namespaces

• namespace internal

Records

• class BasicLeakyAllocator

• class OwningAllocateFunction

• class PageAllocator

• class PosixMmap

• class SealedPageAllocator

• class SealedPageAllocator

• class SingleHeapAllocator

• class ZirconVmar

Functions

• template <MemoryApi Memory>

  PageAllocator<std::decay_t<Memory>> <deduction guide for PageAllocator> (Memory )

  Deduction guide.

• template <typename T>

  BasicLeakyAllocator<std::conditional_t<std::is_lvalue_reference_v<T> && !std::is_const_v<std::remove_reference_t<T>>, T, std::decay_t<T>>> <deduction guide for BasicLeakyAllocator> (T && allocate)

  Deduction guides.

• template <typename T>

  auto BasicOwningAllocator (T && allocator)

  This takes an AllocateFunction and returns another allocator that works much

  like the object from trivial_allocator::BasicLeakyAllocator(allocator)

  would. The difference is that the underlying allocations are all owned by

  the allocator object so all the space used for the "leaky" allocations is

  actually reclaimed when the allocator object dies.

  Defined at line 31 of file ../../src/lib/trivial-allocator/include/lib/trivial-allocator/basic-owning-allocator.h

Concepts

template <typename T> MemoryApi std::movable<typename T::Capability> && std::is_default_constructible_v<typename T::Capability> && requires (const T const_memory, T memory, typename T::Capability cap, void *alloc, size_t size) { { const_memory.page_size() } -> std::convertible_to<std::size_t>; { memory.Allocate(size) } -> std::convertible_to<std::pair<void *, typename T::Capability>>; { memory.Deallocate(std::move(cap), alloc, size) }; { memory.Release(std::move(cap), alloc, size) }; }

template <typename T> SealableMemory MemoryApi<T> && requires (T memory, typename T::Capability cap, void *alloc, size_t size) { { memory.Seal(std::move(cap), alloc, size) }; }