Struct alloc::allocator::Layout

pub struct Layout { /* fields omitted */ }

🔬 This is a nightly-only experimental API. (allocator_api #32838)

the precise API and guarantees it provides may be tweaked slightly, especially to possibly take into account the types being stored to make room for a future tracing garbage collector

Layout of a block of memory.

An instance of Layout describes a particular layout of memory. You build a Layout up as an input to give to an allocator.

All layouts have an associated non-negative size and a power-of-two alignment.

(Note however that layouts are not required to have positive size, even though many allocators require that all memory requests have positive size. A caller to the Alloc::alloc method must either ensure that conditions like this are met, or use specific allocators with looser requirements.)

Methods

impl Layout

pub fn from_size_align(size: usize, align: usize) -> Option<Layout>

🔬 This is a nightly-only experimental API. (allocator_api #32838)

the precise API and guarantees it provides may be tweaked slightly, especially to possibly take into account the types being stored to make room for a future tracing garbage collector

Constructs a Layout from a given size and align, or returns None if any of the following conditions are not met:

• align must be a power of two,

• align must not exceed 2³¹ (i.e. 1 << 31),

• size, when rounded up to the nearest multiple of align, must not overflow (i.e. the rounded value must be less than usize::MAX).

pub unsafe fn from_size_align_unchecked(size: usize, align: usize) -> Layout

🔬 This is a nightly-only experimental API. (allocator_api #32838)

the precise API and guarantees it provides may be tweaked slightly, especially to possibly take into account the types being stored to make room for a future tracing garbage collector

Creates a layout, bypassing all checks.

Safety

This function is unsafe as it does not verify that align is a power-of-two that is also less than or equal to 2³¹, nor that size aligned to align fits within the address space (i.e. the Layout::from_size_align preconditions).

pub fn size(&self) -> usize

🔬 This is a nightly-only experimental API. (allocator_api #32838)

the precise API and guarantees it provides may be tweaked slightly, especially to possibly take into account the types being stored to make room for a future tracing garbage collector

The minimum size in bytes for a memory block of this layout.

pub fn align(&self) -> usize

🔬 This is a nightly-only experimental API. (allocator_api #32838)

the precise API and guarantees it provides may be tweaked slightly, especially to possibly take into account the types being stored to make room for a future tracing garbage collector

The minimum byte alignment for a memory block of this layout.

pub fn new<T>() -> Self

🔬 This is a nightly-only experimental API. (allocator_api #32838)

the precise API and guarantees it provides may be tweaked slightly, especially to possibly take into account the types being stored to make room for a future tracing garbage collector

Constructs a Layout suitable for holding a value of type T.

pub fn for_value<T: ?Sized>(t: &T) -> Self

🔬 This is a nightly-only experimental API. (allocator_api #32838)

the precise API and guarantees it provides may be tweaked slightly, especially to possibly take into account the types being stored to make room for a future tracing garbage collector

Produces layout describing a record that could be used to allocate backing structure for T (which could be a trait or other unsized type like a slice).

pub fn align_to(&self, align: usize) -> Self

🔬 This is a nightly-only experimental API. (allocator_api #32838)

the precise API and guarantees it provides may be tweaked slightly, especially to possibly take into account the types being stored to make room for a future tracing garbage collector

Creates a layout describing the record that can hold a value of the same layout as self, but that also is aligned to alignment align (measured in bytes).

If self already meets the prescribed alignment, then returns self.

Note that this method does not add any padding to the overall size, regardless of whether the returned layout has a different alignment. In other words, if K has size 16, K.align_to(32) will still have size 16.

Panics

Panics if the combination of self.size and the given align violates the conditions listed in from_size_align.

pub fn padding_needed_for(&self, align: usize) -> usize

🔬 This is a nightly-only experimental API. (allocator_api #32838)

the precise API and guarantees it provides may be tweaked slightly, especially to possibly take into account the types being stored to make room for a future tracing garbage collector

Returns the amount of padding we must insert after self to ensure that the following address will satisfy align (measured in bytes).

E.g. if self.size is 9, then self.padding_needed_for(4) returns 3, because that is the minimum number of bytes of padding required to get a 4-aligned address (assuming that the corresponding memory block starts at a 4-aligned address).

The return value of this function has no meaning if align is not a power-of-two.

Note that the utility of the returned value requires align to be less than or equal to the alignment of the starting address for the whole allocated block of memory. One way to satisfy this constraint is to ensure align <= self.align.

pub fn repeat(&self, n: usize) -> Option<(Self, usize)>

🔬 This is a nightly-only experimental API. (allocator_api #32838)

the precise API and guarantees it provides may be tweaked slightly, especially to possibly take into account the types being stored to make room for a future tracing garbage collector

Creates a layout describing the record for n instances of self, with a suitable amount of padding between each to ensure that each instance is given its requested size and alignment. On success, returns (k, offs) where k is the layout of the array and offs is the distance between the start of each element in the array.

On arithmetic overflow, returns None.

pub fn extend(&self, next: Self) -> Option<(Self, usize)>

🔬 This is a nightly-only experimental API. (allocator_api #32838)

the precise API and guarantees it provides may be tweaked slightly, especially to possibly take into account the types being stored to make room for a future tracing garbage collector

Creates a layout describing the record for self followed by next, including any necessary padding to ensure that next will be properly aligned. Note that the result layout will satisfy the alignment properties of both self and next.

Returns Some((k, offset)), where k is layout of the concatenated record and offset is the relative location, in bytes, of the start of the next embedded within the concatenated record (assuming that the record itself starts at offset 0).

On arithmetic overflow, returns None.

pub fn repeat_packed(&self, n: usize) -> Option<Self>

🔬 This is a nightly-only experimental API. (allocator_api #32838)

the precise API and guarantees it provides may be tweaked slightly, especially to possibly take into account the types being stored to make room for a future tracing garbage collector

Creates a layout describing the record for n instances of self, with no padding between each instance.

Note that, unlike repeat, repeat_packed does not guarantee that the repeated instances of self will be properly aligned, even if a given instance of self is properly aligned. In other words, if the layout returned by repeat_packed is used to allocate an array, it is not guaranteed that all elements in the array will be properly aligned.

On arithmetic overflow, returns None.

pub fn extend_packed(&self, next: Self) -> Option<(Self, usize)>

🔬 This is a nightly-only experimental API. (allocator_api #32838)

the precise API and guarantees it provides may be tweaked slightly, especially to possibly take into account the types being stored to make room for a future tracing garbage collector

Creates a layout describing the record for self followed by next with no additional padding between the two. Since no padding is inserted, the alignment of next is irrelevant, and is not incorporated at all into the resulting layout.

Returns (k, offset), where k is layout of the concatenated record and offset is the relative location, in bytes, of the start of the next embedded within the concatenated record (assuming that the record itself starts at offset 0).

(The offset is always the same as self.size(); we use this signature out of convenience in matching the signature of extend.)

On arithmetic overflow, returns None.

pub fn array<T>(n: usize) -> Option<Self>

🔬 This is a nightly-only experimental API. (allocator_api #32838)

the precise API and guarantees it provides may be tweaked slightly, especially to possibly take into account the types being stored to make room for a future tracing garbage collector

Creates a layout describing the record for a [T; n].

On arithmetic overflow, returns None.

Trait Implementations

impl Clone for Layout

fn clone(&self) -> Layout

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Layout

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl PartialEq for Layout

fn eq(&self, __arg_0: &Layout) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &Layout) -> bool

This method tests for !=.

impl Eq for Layout