Struct Unique

pub struct Unique<'a, T: ?Sized, D: Deleter> { /* private fields */ }

Smart pointer, that owns and manages object via its pointer.

On Drop it automatically disposes of pointer with provided deleter.

Useful in C FFI context.

Safety

If you use Deleter that relies on type information, you must guarantee that object was created using the same type as pointer, which points to it.

Which means you must guarantee that specified pointer is valid one and points to existing memory storage, which is already initialized.

Trait implementation

Due to assumption that Unique pointer always has valid value (you need to use unsafe code to create invalid one)

All trait implementations, except pointer specific one (e.g. fmt::Pointer), implements corresponding traits by delegating call to underlying value.

Implementations

impl<T> Unique<'static, T, GlobalDeleter>

pub fn boxed(val: T) -> Self

Creates new instance using global allocator

impl<T: ?Sized> Unique<'static, T, GlobalDeleter>

pub fn into_boxed(self) -> Box<T>

Converts ptr to box

impl<'a, T: ?Sized, D: Deleter> Unique<'a, T, D>

pub unsafe fn new(ptr: *mut T) -> Self

Creates new instance from raw pointer and Deleter instance

Panics

• If pointer is null

pub unsafe fn from_ptr(ptr: *mut T) -> Option<Self>

Creates instance from raw pointer, checking if pointer is null.

Returns None if pointer is null.

pub unsafe fn from_ptr_unchecked(ptr: *mut T) -> Self

Creates instance from raw pointer, without checking if pointer is null.

User must ensure that pointer is non-null

pub fn get(&self) -> *mut T

Gets underlying raw pointer.

Note that it is illegal to create multiple mutable references so care must be taken when converting raw pointer into mutable reference.

pub fn as_ref(&self) -> &T

Gets reference to underlying data.

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

Gets mutable reference to underlying data.

pub fn cast<N>(&self) -> *mut N

Retrieves pointer as of type

pub fn const_cast<N>(&self) -> *const N

Retrieves pointer as of type and const

pub fn swap(&mut self, other: &mut Self)

Swaps underlying pointers between instances

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

Releases the ownership and returns raw pointer, without dropping it.

Trait Implementations

impl<'a, T: ?Sized + Debug, D: Deleter> Debug for Unique<'a, T, D>

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

Formats the value using the given formatter.

impl<'a, T: ?Sized, D: Deleter> Deref for Unique<'a, T, D>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<'a, T: ?Sized, D: Deleter> DerefMut for Unique<'a, T, D>

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

Mutably dereferences the value.

impl<'a, T: ?Sized + Display, D: Deleter> Display for Unique<'a, T, D>

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

Formats the value using the given formatter.

impl<'a, T: ?Sized, D: Deleter> Drop for Unique<'a, T, D>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T: ?Sized> From<&'a mut T> for Unique<'a, T, ()>

fn from(ptr: &'a mut T) -> Self

Converts to this type from the input type.

impl<'a, T: ?Sized + Hash, D: Deleter> Hash for Unique<'a, T, D>

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, T: ?Sized + PartialEq, D: Deleter> PartialEq for Unique<'a, T, D>

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

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

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

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

impl<'a, T: ?Sized + PartialOrd, D: Deleter> PartialOrd for Unique<'a, T, D>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a, T: ?Sized, D: Deleter> Pointer for Unique<'a, T, D>

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

Formats the value using the given formatter.

impl<'a, T: ?Sized + Eq, D: Deleter> Eq for Unique<'a, T, D>

impl<'a, T: ?Sized + Send, D: Deleter> Send for Unique<'a, T, D>

impl<'a, T: ?Sized + Sync, D: Deleter> Sync for Unique<'a, T, D>

impl<'a, T: ?Sized + Unpin, D: Deleter> Unpin for Unique<'a, T, D>

impl<'a, T: ?Sized + RefUnwindSafe, D: Deleter> UnwindSafe for Unique<'a, T, D>