Struct owned_alloc::OwnedAlloc

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

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>.

Methods

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: ?Sized> Sync for OwnedAlloc<T> where     T: Sync,

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

fn from(val: T) -> Self

Performs the conversion.

impl<T> From<OwnedAlloc<T>> for MaybeUninitAlloc<T> where     T: ?Sized,

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

Performs the conversion.

impl<T: ?Sized> Send for OwnedAlloc<T> where     T: Send,

impl<T> Clone for OwnedAlloc<T> where     T: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Drop for OwnedAlloc<T> where     T: ?Sized,

fn drop(&mut self)

Executes the destructor for this type.

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.