Struct fallacy_box::Box

#[repr(transparent)]
pub struct Box<T: ?Sized, A: Allocator = Global>(_);

A pointer type for heap allocation.

Implementations

impl<T> Box<T>

pub fn try_new(x: T) -> Result<Self, AllocError>

Allocates memory on the heap then places x into it, returning an error if the allocation fails

This doesn’t actually allocate if T is zero-sized.

impl<T: ?Sized> Box<T>

pub unsafe fn from_raw(raw: *mut T) -> Self

Constructs a box from a raw pointer.

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

This function is unsafe because improper use may lead to memory problems. For example, a double-free may occur if the function is called twice on the same raw pointer.

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

pub fn try_new_in(x: T, alloc: A) -> Result<Self, AllocError>

Allocates memory in the given allocator then places x into it, returning an error if the allocation fails

This doesn’t actually allocate if T is zero-sized.

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

pub unsafe fn from_raw_in(raw: *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

This function is unsafe because improper use may lead to memory problems. For example, a double-free may occur if the function is called twice on the same raw pointer.

pub fn into_raw(b: Self) -> *mut T

Consumes the Box, returning a wrapped raw pointer.

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 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(b) instead of b.into_raw(). This is so that there is no conflict with a method on the inner type.

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.

pub fn allocator(b: &Self) -> &A

Returns a reference to the underlying allocator.

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

pub fn leak<'a>(b: Self) -> &'a mut T where
    A: 'a, 

Consumes and leaks the Box, returning a mutable reference, &'a mut T. Note that the type T must outlive the chosen lifetime 'a. If the type has only static references, or none at all, then this may be chosen to be 'static.

This function is mainly useful for data that lives for the remainder of the program’s life. Dropping the returned reference will cause a memory leak. If this is not acceptable, the reference should first be wrapped with the Box::from_raw function producing a Box. This Box can then be dropped which will properly destroy T and release the allocated memory.

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

pub fn into_std(self) -> StdBox<T, A>

pub fn from_std(b: StdBox<T, A>) -> Self

Trait Implementations

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

fn as_mut(&mut self) -> &mut T

Converts this type into a mutable reference of the (usually inferred) input type.

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

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

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) -> &T

Dereferences the value.

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

fn deref_mut(&mut self) -> &mut T

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: Hash + ?Sized, A: Hash + Allocator> Hash for Box<T, A>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

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

fn cmp(&self, other: &Box<T, A>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

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

fn eq(&self, other: &Box<T, A>) -> bool

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

fn ne(&self, other: &Box<T, A>) -> bool

This method tests for !=.

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

fn partial_cmp(&self, other: &Box<T, A>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

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

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

Formats the value using the given formatter.

impl<T: TryClone, A: Allocator + TryClone> TryClone for Box<T, A>

fn try_clone(&self) -> Result<Self, AllocError>

fn try_clone_from(&mut self, source: &Self) -> Result<(), AllocError>

Performs copy-assignment from source.

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

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

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