Struct situ::OwnedVal

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

A pointer type for memory allocation.

Implementations

impl<T: DropRaw + ?Sized, A: Allocator> OwnedVal<T, A>

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

Returns a reference to the underlying allocator.

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

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

Constructs an owned Val from a raw pointer in the given allocator.

After calling this function, the raw pointer is owned by the resulting OwnedVal. Specifically, the OwnedVal destructor will call the DropRaw 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 OwnedVal.

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 unsafe fn assume_init(frame: Frame<T, A>) -> Selfwhere
    T: Pointee,
    <T as Pointee>::Metadata: Metadata<T>,

Constructs an owned Val from an initialized Frame.

Safety

frame must be initialized.

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

Consumes the OwnedVal, 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 OwnedVal. In particular, the caller should properly destroy T with DropRaw and release the memory, taking into account the memory layout used by OwnedVal. The easiest way to do this is to convert the raw pointer back into an OwnedVal with the OwnedVal::from_raw_in function, allowing the OwnedVal destructor to perform the cleanup.

Note: this is an associated function, which means that you have to call it as OwnedVal::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 as_ref(&self) -> Ref<'_, T>

Returns a Ref of the owned value.

pub fn as_mut(&mut self) -> Mut<'_, T>

Returns a Mut of the owned value.

impl<T: DropRaw, A: Allocator> OwnedVal<T, A>

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

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

impl<T: DropRaw> OwnedVal<T, Global>

pub fn new(x: T) -> Self

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

Trait Implementations

impl<T, A> Debug for OwnedVal<T, A>where
    T: DebugRaw + DropRaw + ?Sized,
    A: Allocator,

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

Formats the value using the given formatter.

impl<T: DropRaw + ?Sized, A: Allocator> Deref for OwnedVal<T, A>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: DropRaw + Unpin + ?Sized, A: Allocator> DerefMut for OwnedVal<T, A>

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

Mutably dereferences the value.

impl<T, A> Display for OwnedVal<T, A>where
    T: DisplayRaw + DropRaw + ?Sized,
    A: Allocator,

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

Formats the value using the given formatter.

impl<T: DropRaw + ?Sized, A: Allocator> Drop for OwnedVal<T, A>

fn drop(&mut self)

Executes the destructor for this type.

impl<T, A> Pointer for OwnedVal<T, A>where
    T: DropRaw + Pointee + ?Sized,
    A: Allocator,

type Target = T

The target value of this type.

fn target(&self) -> *mut Self::Target

Returns a pointer to this type’s target.

impl<T, A> Within<<A as RegionalAllocator>::Region> for OwnedVal<T, A>where
    T: DropRaw + Pointee + ?Sized,
    A: RegionalAllocator,