Struct OwnedAlloc

pub struct OwnedAlloc<T>
where
    T: ?Sized,
{ /* private fields */ }

Dynamic allocation of a T whose memory is considered fully initialized. The allocation and its content are freed on drop. Similar to a Box. If the size of the allocation is zero, no allocation is performed and a dangling pointer is used (just like in std). For the drop checker, the type acts as if it contains a T due to usage of PhantomData<T>.

Implementations

impl<T> OwnedAlloc<T>

pub fn new(val: T) -> Self

Creates an allocation and initializes it to the passed argument. In case of allocation error, the handler registered via stdlib is called.

pub fn try_new(val: T) -> Result<Self, AllocErr>

Creates an allocation and initializes it to the passed argument. In case of allocation error, Err is returned.

pub fn move_inner(self) -> (T, UninitAlloc<T>)

Moves the stored value out from the allocation. The value and the allocation now considered uninitialized are returned.

impl<T> OwnedAlloc<T>

where T: ?Sized,

pub unsafe fn from_raw(nnptr: NonNull<T>) -> Self

Recreate the OwnedAlloc from a raw non-null pointer.

Safety

This functions is unsafe because passing the wrong pointer leads to undefined behaviour. Passing a pointer to uninitialized memory is also undefined behaviour.

pub unsafe fn from_box(boxed: Box<T>) -> Self

Converts the plain old standard library Box into an owned allocation.

Safety

This function is unsafe because there are no guarantees that Box and OwnedAlloc allocate in the same way. They probably do in the Rust version you are using, but there are no future guarantees.

pub fn raw(&self) -> NonNull<T>

Returns the raw non-null pointer of the allocation.

pub fn into_raw(self) -> NonNull<T>

“Forgets” dropping both the allocation and its content and returns its raw non-null pointer.

pub unsafe fn into_box(self) -> Box<T>

Converts the owned allocation into a plain old standard library Box.

Safety

This function is unsafe because there are no guarantees that Box and OwnedAlloc allocate in the same way. They probably do in the Rust version you are using, but there are no future guarantees.

pub fn drop_in_place(self) -> UninitAlloc<T>

Drops the memory and returns the allocation now considered uninitialized.

pub fn forget_inner(self) -> UninitAlloc<T>

“Forgets” about dropping the inner value and returns an uninitialized allocation.

Trait Implementations

impl<T> Clone for OwnedAlloc<T>

where T: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for OwnedAlloc<T>

where T: ?Sized,

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

Formats the value using the given formatter.

impl<T> Deref for OwnedAlloc<T>

where T: ?Sized,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> DerefMut for OwnedAlloc<T>

where T: ?Sized,

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

Mutably dereferences the value.

impl<T> Drop for OwnedAlloc<T>

where T: ?Sized,

fn drop(&mut self)

Executes the destructor for this type.

impl<T> From<OwnedAlloc<T>> for MaybeUninitAlloc<T>

where T: ?Sized,

fn from(alloc: OwnedAlloc<T>) -> Self

Converts to this type from the input type.

impl<T> From<T> for OwnedAlloc<T>

fn from(val: T) -> Self

Converts to this type from the input type.

impl<T> Send for OwnedAlloc<T>

where T: ?Sized + Send,

impl<T> Sync for OwnedAlloc<T>

where T: ?Sized + Sync,