Struct Box

#[repr(C)]
pub struct Box<T, Alloc: IAlloc = DefaultAllocator> { /* private fields */ }

An ABI-stable Box, provided Alloc is ABI-stable.

Implementations

impl<T, Alloc: IAlloc> Box<T, Alloc>

where Struct<AllocPtr<T, Alloc>>: IStable, AllocPtr<T, Alloc>: IStable,

pub const fn has_optimal_layout() -> bool

Returns true if the layout for Box is smaller or equal to that Rust would have generated for it.

impl<T> Box<T>

pub unsafe fn make<F: for<'a> FnOnce(&'a mut MaybeUninit<T>) -> Result<&'a mut T, ()>>( constructor: F, ) -> Result<Self, Box<MaybeUninit<T>>>

Attempts to allocate Self, initializing it with constructor.

Note that the allocation may or may not be zeroed.

If the allocation fails, the constructor will not be run.

Safety

constructor MUST return Err(()) if it failed to initialize the passed argument.

Errors

Returns the uninitialized allocation if the constructor declares a failure.

Panics

If the allocator fails to provide an appropriate allocation.

pub fn new(value: T) -> Self

Attempts to allocate Self and store value in it.

Panics

If the allocator fails to provide an appropriate allocation.

impl<T, Alloc: IAlloc> Box<T, Alloc>

pub unsafe fn try_make_in<F: for<'a> FnOnce(&'a mut MaybeUninit<T>) -> Result<&'a mut T, ()>>( constructor: F, alloc: Alloc, ) -> Result<Self, Result<Box<MaybeUninit<T>, Alloc>, (F, Alloc)>>

Attempts to allocate Self, initializing it with constructor.

Note that the allocation may or may not be zeroed.

If the constructor panics, the allocated memory will be leaked.

Errors

• Returns the constructor and the allocator in case of allocation failure.
• Returns the uninitialized allocated memory if constructor fails.

Safety

constructor MUST return Err(()) if it failed to initialize the passed argument.

Notes

Note that the allocation may or may not be zeroed.

pub fn try_new_in(value: T, alloc: Alloc) -> Result<Self, (T, Alloc)>

Attempts to allocate a Self and store value in it

Errors

Returns value and the allocator in case of failure.

pub unsafe fn make_in<F: for<'a> FnOnce(&'a mut MaybeUninit<T>) -> Result<&'a mut T, ()>>( constructor: F, alloc: Alloc, ) -> Result<Self, Box<MaybeUninit<T>, Alloc>>

Attempts to allocate Self, initializing it with constructor.

Note that the allocation may or may not be zeroed.

Errors

Returns the uninitialized allocated memory if constructor fails.

Safety

constructor MUST return Err(()) if it failed to initialize the passed argument.

Panics

If the allocator fails to provide an appropriate allocation.

pub fn new_in(value: T, alloc: Alloc) -> Self

Attempts to allocate Self and store value in it.

Panics

If the allocator fails to provide an appropriate allocation.

pub fn into_inner(this: Self) -> T

Extracts the value from the allocation, freeing said allocation.

pub const fn into_raw(this: Self) -> AllocPtr<T, Alloc>

Returns the pointer to the inner raw allocation, leaking this.

Note that the pointer may be dangling if T is zero-sized.

pub const unsafe fn from_raw(this: AllocPtr<T, Alloc>) -> Self

Constructs Self from a raw allocation.

Safety

No other container must own (even partially) this.

Trait Implementations

impl<T: Clone, Alloc: IAlloc + Clone> Clone for Box<T, Alloc>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, Alloc: IAlloc> Deref for Box<T, Alloc>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, Alloc: IAlloc> DerefMut for Box<T, Alloc>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T, Alloc: IAlloc> Drop for Box<T, Alloc>

fn drop(&mut self)

Executes the destructor for this type.

impl<T, Alloc: IAlloc> IPtr for Box<T, Alloc>

unsafe fn as_ref(&self) -> AnonymRef<'_>

Safety

impl<T, Alloc: IAlloc> IPtrMut for Box<T, Alloc>

unsafe fn as_mut(&mut self) -> AnonymRefMut<'_>

Safety

impl<T, Alloc: IAlloc> IPtrOwned for Box<T, Alloc>

fn drop( this: &mut ManuallyDrop<Self>, drop: unsafe extern "C" fn(AnonymRefMut<'_>), )

Called instead of Drop::drop when the dynptr is dropped.

impl<T, Alloc: IAlloc> IStable for Box<T, Alloc>

where Struct<AllocPtr<T, Alloc>>: IStable, AllocPtr<T, Alloc>: IStable,

const REPORT: &'static TypeReport

A compile-time generated report of the fields of the type, allowing for compatibility inspection.

const ID: u64

A stable (and ideally unique) identifier for the type. Often generated using crate::report::gen_id, but can be manually set.

type ForbiddenValues = <Struct<AllocPtr<T, Alloc>> as IStable>::ForbiddenValues

The values that the annotated type cannot occupy.

type UnusedBits = <Struct<AllocPtr<T, Alloc>> as IStable>::UnusedBits

The padding bits in the annotated types

type Size = <Struct<AllocPtr<T, Alloc>> as IStable>::Size

The size of the annotated type in bytes.

type Align = <Struct<AllocPtr<T, Alloc>> as IStable>::Align

The alignment of the annotated type in bytes.

type HasExactlyOneNiche = <Struct<AllocPtr<T, Alloc>> as IStable>::HasExactlyOneNiche

Allows the detection of whether or not core::option::Options are stable:

type ContainsIndirections = <Struct<AllocPtr<T, Alloc>> as IStable>::ContainsIndirections

Whether or not the type contains indirections (pointers, indices in independent data-structures…)

fn size() -> usize

Returns the size of the type.

fn align() -> usize

Returns the alignment of the type.

unsafe fn is_invalid(ptr: *const u8) -> bool

Returns true if ptr points to memory that cannot be a valid value of Self.

impl<T, Alloc: IAlloc> IntoDyn for Box<T, Alloc>

type Anonymized = Box<(), Alloc>

A pointer type with type information discarded.

type Target = T

The original pointee.

fn anonimize(self) -> Self::Anonymized

Drop the type information from the pointer.

impl<T: Send, Alloc: IAlloc + Send> Send for Box<T, Alloc>

impl<T: Sync, Alloc: IAlloc> Sync for Box<T, Alloc>