Struct Owned

pub struct Owned<T, A>(/* private fields */)
where
    T: ?Sized,
    A: TrMalloc + Clone;

A smart pointer with specified allocator.

Implementations

impl<T, A> Owned<T, A>

where A: TrMalloc + Clone,

pub fn new(data: T, alloc: A) -> Self

pub fn pin(data: T, alloc: A) -> Pin<Self>

impl<T, A> Owned<[T], A>

where A: TrMalloc + Clone,

pub fn new_slice( len: usize, init_each: impl FnMut(usize) -> T, alloc: A, ) -> Self

impl<T, A> Owned<[MaybeUninit<T>], A>

where A: TrMalloc + Clone,

pub fn new_uninit_slice(len: usize, alloc: A) -> Self

impl<'a, T, A> Owned<T, A>

where T: ?Sized, A: 'a + TrMalloc + Clone,

pub fn leak(owned: Owned<T, A>) -> &'a mut T

impl<T, A> Owned<T, A>

where T: ?Sized, A: TrMalloc + Clone,

pub unsafe fn from_raw(raw: *mut T) -> Owned<T, A>

Constructs an Owned<T, A> from a raw resource.

After calling this function, the raw resource is owned by the resulting Owned<T, A>. Specifically, the Owned 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 Owned<T, A> .

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.

Examples

use core_malloc::CoreAlloc;
use mm_ptr::{Owned, XtMallocOwned};

let x = CoreAlloc::default().owned("hello".to_owned());
let x_ptr = Owned::leak(x);

unsafe {
    // Convert back to an `Owned` to prevent leak.
    let x = Owned::<String, CoreAlloc>::from_raw(x_ptr);
    assert_eq!(&*x, "hello");

    // Further calls to `Owned::from_raw(x_ptr)` would be memory-unsafe.
}

// The memory was freed when `x` went out of scope above, so `x_ptr` is
// now dangling!

pub const fn malloc(&self) -> &A

pub const fn as_ptr(&self) -> *const T

Trait Implementations

impl<T, A> Borrow<T> for Owned<T, A>

where T: ?Sized, A: TrMalloc + Clone,

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T, A> BorrowMut<T> for Owned<T, A>

where T: ?Sized, A: TrMalloc + Clone,

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

Mutably borrows from an owned value.

impl<T, A> Debug for Owned<T, A>

where T: ?Sized + Debug, A: TrMalloc + Clone + Debug,

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

Formats the value using the given formatter.

impl<T, A> Deref for Owned<T, A>

where T: ?Sized, A: TrMalloc + Clone,

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, A> DerefMut for Owned<T, A>

where T: ?Sized, A: TrMalloc + Clone,

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

Mutably dereferences the value.

impl<T, A> Drop for Owned<T, A>

where T: ?Sized, A: TrMalloc + Clone,

fn drop(&mut self)

Executes the destructor for this type.

impl<T, A> PartialEq for Owned<T, A>

where T: ?Sized, A: TrMalloc + Clone,

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, A> Pointer for Owned<T, A>

where T: ?Sized, A: TrMalloc + Clone,

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

Formats the value using the given formatter.

impl<T, A> TrBoxed for Owned<T, A>

where T: ?Sized, A: TrMalloc + Clone,

type Malloc = A

fn malloc(&self) -> &Self::Malloc

impl<T, A> Eq for Owned<T, A>

where T: ?Sized, A: TrMalloc + Clone,

impl<T, A> Send for Owned<T, A>

where T: ?Sized + Send, A: TrMalloc + Clone,

impl<T, A> Sync for Owned<T, A>

where T: ?Sized + Sync, A: TrMalloc + Clone,

impl<T, A> TrUnique for Owned<T, A>

where T: ?Sized, A: TrMalloc + Clone,