Struct UniquePtr

#[repr(C)]
pub struct UniquePtr<T>
where
    T: UniquePtrTarget,
{ /* private fields */ }

Binding to C++ std::unique_ptr<T, std::default_delete<T>>.

Implementations

impl<T> UniquePtr<T>

where T: UniquePtrTarget,

pub fn null() -> Self

Makes a new UniquePtr wrapping a null pointer.

Matches the behavior of default-constructing a std::unique_ptr.

pub fn new(value: T) -> Self

where T: ExternType<Kind = Trivial>,

Allocates memory on the heap and makes a UniquePtr pointing to it.

pub fn is_null(&self) -> bool

Checks whether the UniquePtr does not own an object.

This is the opposite of std::unique_ptr<T>::operator bool.

pub fn as_ref(&self) -> Option<&T>

Returns a reference to the object owned by this UniquePtr if any, otherwise None.

pub fn as_mut(&mut self) -> Option<Pin<&mut T>>

Returns a mutable pinned reference to the object owned by this UniquePtr if any, otherwise None.

pub fn pin_mut(&mut self) -> Pin<&mut T>

Returns a mutable pinned reference to the object owned by this UniquePtr.

Panics

Panics if the UniquePtr holds a null pointer.

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

Returns a raw const pointer to the object owned by this UniquePtr if any, otherwise the null pointer.

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

Returns a raw mutable pointer to the object owned by this UniquePtr if any, otherwise the null pointer.

As with std::unique_ptr<T>::get, this doesn’t require that you hold an exclusive reference to the UniquePtr. This differs from Rust norms, so extra care should be taken in the way the pointer is used.

pub fn into_raw(self) -> *mut T

Consumes the UniquePtr, releasing its ownership of the heap-allocated T.

Matches the behavior of std::unique_ptr<T>::release.

pub unsafe fn from_raw(raw: *mut T) -> Self

Constructs a UniquePtr retaking ownership of a pointer previously obtained from into_raw.

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.

Trait Implementations

impl<T> Debug for UniquePtr<T>

where T: Debug + UniquePtrTarget,

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

Formats the value using the given formatter.

impl<T> Deref for UniquePtr<T>

where T: UniquePtrTarget,

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for UniquePtr<T>

where T: UniquePtrTarget + Unpin,

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

Mutably dereferences the value.

impl<T> Display for UniquePtr<T>

where T: Display + UniquePtrTarget,

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

Formats the value using the given formatter.

impl<T> Drop for UniquePtr<T>

where T: UniquePtrTarget,

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Hash for UniquePtr<T>

where T: Hash + UniquePtrTarget,

fn hash<H>(&self, hasher: &mut H)

where H: Hasher,

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<T> Ord for UniquePtr<T>

where T: Ord + UniquePtrTarget,

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T> PartialEq for UniquePtr<T>

where T: PartialEq + UniquePtrTarget,

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> PartialOrd for UniquePtr<T>

where T: PartialOrd + UniquePtrTarget,

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<T> Read for UniquePtr<T>

where for<'a> Pin<&'a mut T>: Read, T: UniquePtrTarget,

Forwarding Read trait implementation in a manner similar to Box<T>.

Note that the implementation will panic for null UniquePtr<T>.

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize>

Reads all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize>

Reads all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<()>

Reads the exact number of bytes required to fill buf.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

impl<T> Seek for UniquePtr<T>

where for<'a> Pin<&'a mut T>: Seek, T: UniquePtrTarget,

Forwarding Seek trait implementation in a manner similar to Box<T>.

Note that the implementation will panic for null UniquePtr<T>.

fn seek(&mut self, pos: SeekFrom) -> Result<u64>

Seek to an offset, in bytes, in a stream.

fn rewind(&mut self) -> Result<()>

Rewind to the beginning of a stream.

fn stream_position(&mut self) -> Result<u64>

Returns the current seek position from the start of the stream.

fn seek_relative(&mut self, offset: i64) -> Result<()>

Seeks relative to the current position.

fn stream_len(&mut self) -> Result<u64, Error>

🔬This is a nightly-only experimental API. (seek_stream_len)

Returns the length of this stream (in bytes).

impl<T> Write for UniquePtr<T>

where for<'a> Pin<&'a mut T>: Write, T: UniquePtrTarget,

Forwarding Write trait implementation in a manner similar to Box<T>.

Note that the implementation will panic for null UniquePtr<T>.

fn write(&mut self, buf: &[u8]) -> Result<usize>

Writes a buffer into this writer, returning how many bytes were written.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize>

Like write, except that it writes from a slice of buffers.

fn flush(&mut self) -> Result<()>

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_all(&mut self, buf: &[u8]) -> Result<()>

Attempts to write an entire buffer into this writer.

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

Writes a formatted string into this writer, returning any error encountered.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.

impl<T> Eq for UniquePtr<T>

where T: Eq + UniquePtrTarget,

impl<T> Send for UniquePtr<T>

where T: Send + UniquePtrTarget,

impl<T> Sync for UniquePtr<T>

where T: Sync + UniquePtrTarget,

impl<T> Unpin for UniquePtr<T>

where T: UniquePtrTarget,