1.28.0[−][src]Struct alloc::alloc::Layout
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 size and a power-of-two alignment.
(Note that layouts are not required to have non-zero size,
even though GlobalAlloc requires that all memory requests
be non-zero in size. A caller must either ensure that conditions
like this are met, use specific allocators with looser
requirements, or use the more lenient AllocRef interface.)
Implementations
impl Layout[src]
pub fn from_size_align(size: usize, align: usize) -> Result<Layout, LayoutErr>[src]
Constructs a Layout from a given size and align,
or returns LayoutErr if any of the following conditions
are not met:
-
alignmust not be zero, -
alignmust be a power of two, -
size, when rounded up to the nearest multiple ofalign, must not overflow (i.e., the rounded value must be less than or equal tousize::MAX).
pub const unsafe fn from_size_align_unchecked(
size: usize,
align: usize
) -> Layout[src]
size: usize,
align: usize
) -> Layout
Creates a layout, bypassing all checks.
Safety
This function is unsafe as it does not verify the preconditions from
Layout::from_size_align.
pub fn size(&self) -> usize[src]
The minimum size in bytes for a memory block of this layout.
pub fn align(&self) -> usize[src]
The minimum byte alignment for a memory block of this layout.
pub const fn new<T>() -> Layout[src]
Constructs a Layout suitable for holding a value of type T.
pub fn for_value<T>(t: &T) -> Layout where
T: ?Sized, [src]
T: ?Sized,
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 dangling(&self) -> NonNull<u8>[src]
Creates a NonNull that is dangling, but well-aligned for this Layout.
Note that the pointer value may potentially represent a valid pointer, which means this must not be used as a "not yet initialized" sentinel value. Types that lazily allocate must track initialization by some other means.
pub fn align_to(&self, align: usize) -> Result<Layout, LayoutErr>1.44.0[src]
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.
Returns an error if the combination of self.size() and the given
align violates the conditions listed in
Layout::from_size_align.
pub fn padding_needed_for(&self, align: usize) -> usize[src]
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 pad_to_align(&self) -> Layout1.44.0[src]
Creates a layout by rounding the size of this layout up to a multiple of the layout's alignment.
This is equivalent to adding the result of padding_needed_for
to the layout's current size.
pub fn repeat(&self, n: usize) -> Result<(Layout, usize), LayoutErr>[src]
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 LayoutErr.
pub fn extend(&self, next: Layout) -> Result<(Layout, usize), LayoutErr>1.44.0[src]
Creates a layout describing the record for self followed by
next, including any necessary padding to ensure that next
will be properly aligned, but no trailing padding.
In order to match C representation layout repr(C), you should
call pad_to_align after extending the layout with all fields.
(There is no way to match the default Rust representation
layout repr(Rust), as it is unspecified.)
Note that the alignment of the resulting layout will be the maximum of
those of self and next, in order to ensure alignment of both parts.
Returns Ok((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 LayoutErr.
Examples
To calculate the layout of a #[repr(C)] structure and the offsets of
the fields from its fields' layouts:
pub fn repr_c(fields: &[Layout]) -> Result<(Layout, Vec<usize>), LayoutErr> { let mut offsets = Vec::new(); let mut layout = Layout::from_size_align(0, 1)?; for &field in fields { let (new_layout, offset) = layout.extend(field)?; layout = new_layout; offsets.push(offset); } // Remember to finalize with `pad_to_align`! Ok((layout.pad_to_align(), offsets)) }Run
pub fn repeat_packed(&self, n: usize) -> Result<Layout, LayoutErr>[src]
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 LayoutErr.
pub fn extend_packed(&self, next: Layout) -> Result<Layout, LayoutErr>[src]
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.
On arithmetic overflow, returns LayoutErr.
pub fn array<T>(n: usize) -> Result<Layout, LayoutErr>1.44.0[src]
Creates a layout describing the record for a [T; n].
On arithmetic overflow, returns LayoutErr.
Trait Implementations
impl Clone for Layout[src]
fn clone(&self) -> Layout[src]
fn clone_from(&mut self, source: &Self)1.0.0[src]
impl Copy for Layout[src]
impl Debug for Layout[src]
impl Eq for Layout[src]
impl PartialEq<Layout> for Layout[src]
impl StructuralEq for Layout[src]
impl StructuralPartialEq for Layout[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized, [src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized, [src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized, [src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T[src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
U: From<T>, [src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone, [src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&Self) -> T[src]
fn clone_into(&Self, &mut T)[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]
U: TryFrom<T>,