std.experimental.allocator.building_blocks.scoped_allocator

struct ScopedAllocator(ParentAllocator);

ScopedAllocator delegates all allocation requests to ParentAllocator. When destroyed, the ScopedAllocator object automatically calls deallocate for all memory allocated through its lifetime. (The deallocateAll function is also implemented with the same semantics.)

deallocate is also supported, which is where most implementation effort and overhead of ScopedAllocator go. If deallocate is not needed, a simpler design combining AllocatorList with Region is recommended.

Examples:

import std.experimental.allocator.mallocator : Mallocator;
import std.typecons : Ternary;
ScopedAllocator!Mallocator alloc;
assert(alloc.empty == Ternary.yes);
const b = alloc.allocate(10);
assert(b.length == 10);
assert(alloc.empty == Ternary.no);

Allocator parent;

If ParentAllocator is stateful, parent is a property giving access to an AffixAllocator!ParentAllocator. Otherwise, parent is an alias for AffixAllocator!ParentAllocator.instance.

enum auto alignment;

Alignment offered

size_t goodAllocSize(size_t n);

Forwards to parent.goodAllocSize (which accounts for the management overhead).

void[] allocate(size_t n);

Allocates memory. For management it actually allocates extra memory from the parent.

bool expand(ref void[] b, size_t delta);

Forwards to parent.expand(b, delta).

bool reallocate(ref void[] b, size_t s);

Reallocates b to new size s.

Ternary owns(void[] b);

Forwards to parent.owns(b).

bool deallocate(void[] b);

Deallocates b.

bool deallocateAll();

Deallocates all memory allocated.

const Ternary empty();

Returns Ternary.yes if this allocator is not responsible for any memory, Ternary.no otherwise. (Never returns Ternary.unknown.)