Union ByteStorage

#[repr(C)]
pub union ByteStorage<T, const N: usize> {
    /* private fields */
}

A reusable storage buffer consisting of an array of bytes.

Implementations

impl<T, const N: usize> ByteStorage<T, N>

pub fn as_uninit_slice(&mut self) -> &mut [MaybeUninit<u8>]

Access the buffer contents as a mutable slice.

Trait Implementations

impl<'a, T, const N: usize> AllocateIn for &'a mut ByteStorage<T, N>

type Alloc = Fixed<'a>

The type of the allocator instance

fn allocate_in( self, layout: Layout, ) -> Result<(NonNull<[u8]>, Self::Alloc), AllocError>

Try to allocate a slice of a memory corresponding to layout, returning the new allocation and the allocator instance

fn allocate_zeroed_in( self, layout: Layout, ) -> Result<(NonNull<[u8]>, Self::Alloc), AllocError>

Try to allocate a slice of a memory corresponding to layout, returning the new allocation and the allocator instance. The memory will be initialized with zeroes.

impl<T, const N: usize> ConstDefault for ByteStorage<T, N>

const DEFAULT: Self = _

The constant default value.

impl<T, const N: usize> Debug for ByteStorage<T, N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, const N: usize> Default for ByteStorage<T, N>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, T: 'static, const N: usize> SpillAlloc<'a> for &'a mut ByteStorage<T, N>

type NewIn<A: 'a> = SpillStorage<'a, &'a mut ByteStorage<T, N>, A>

The concrete type of resulting allocation target.

fn spill_alloc_in<A: Allocator + 'a>(self, alloc: A) -> Self::NewIn<A>

Consume the allocator instance, returning a new allocator which spills into the provided allocator instance alloc.

fn spill_alloc(self) -> Self::NewIn<Global>

Consume the allocator instance, returning a new allocator which spills into the Global allocator.

impl<T, const N: usize> Zeroize for ByteStorage<T, N>

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.