Struct heresy::boxed::Box

pub struct Box<T: ?Sized, A: Allocator = Global> { /* private fields */ }

A pointer type for memory allocation.

Implementations

impl<T: ?Sized, A: Allocator> Box<T, A>

pub unsafe fn from_raw_in(ptr: *mut T, alloc: A) -> Self

Constructs a box from a raw pointer in the given allocator.

After calling this function, the raw pointer is owned by the resulting Box. Specifically, the Box destructor will call the destructor of T and free the allocated memory. For this to be safe, the memory must have been allocated in accordance with the memory layout used by Box.

Safety

• ptr must point to a memory block currently allocated by alloc.
• The layout used to allocate ptr must exactly match the return value of Layout::for_value.
• ptr must point to an initialized T.

pub fn into_raw_with_allocator(b: Self) -> (*mut T, A)

Consumes the Box, returning a wrapped raw pointer and the allocator.

The pointer will be properly aligned and non-null.

After calling this function, the caller is responsible for the memory previously managed by the Box. In particular, the caller should properly destroy T and release the memory, taking into account the memory layout used by Box. The easiest way to do this is to convert the raw pointer back into a Box with the Box::from_raw_in function, allowing the Box destructor to perform the cleanup.

Note: this is an associated function, which means that you have to call it as Box::into_raw_with_allocator(b) instead of b.into_raw_with_allocator(). This is so that there is no conflict with a method on the inner type.

impl<T, A: Allocator> Box<T, A>

pub fn new_in(x: T, alloc: A) -> Box<T, A>

Allocates memory in the given allocator then places x into it.

impl<T> Box<T, Global>

pub fn new(x: T) -> Self

Allocates memory in the Global allocator and then places x into it.

Trait Implementations

impl<T: Debug + ?Sized, A: Allocator> Debug for Box<T, A>

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

Formats the value using the given formatter.

impl<T: ?Sized, A: Allocator> Deref for Box<T, A>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: ?Sized, A: Allocator> DerefMut for Box<T, A>

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

Mutably dereferences the value.

impl<T: Display + ?Sized, A: Allocator> Display for Box<T, A>

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

Formats the value using the given formatter.

impl<T: ?Sized, A: Allocator> Drop for Box<T, A>

fn drop(&mut self)

Executes the destructor for this type.