Struct Unique 

pub struct Unique<T: ?Sized>(/* private fields */);

A wrapper around a raw non-null *const T that indicates that the possessor of this wrapper owns the referent. Usefor building abstractions like Box<T>, Vec<T>, String, and HashMap<K, V>.

Unlike *mut T, Unique<T> behaves “as if” it were an instance of T. It implements Send/Sync if T is Send/Sync. It also implies the kind of strong aliasing guarantees an instance of T can expect: the referent of the pointer should not be modified without a unique path to its owning Unique.

If you’re uncertain of whether it’s correct to use Unique for your purposes, consider using NonNull, which has weaker semantics.

Unlike *mut T, the pointer must always be non-null, even if the pointer is never dereferenced. This is so that enums may use this forbidden value as a discriminant – Option<Unique<T>> has the same size as Unique<T>. However the pointer may still dangle if it isn’t dereferenced.

use fdf::Unique;
assert_eq!(size_of::<Unique<u8>>(), size_of::<Option<Unique<u8>>>());
assert_eq!(size_of::<Unique<u8>>(), size_of::<*const u8>());
assert_eq!(size_of::<Unique<usize>>(), size_of::<usize>());

Unlike *mut T, Unique<T> is covariant over T. This should always be correct for any type which upholds Unique’s aliasing requirements.

Implementations

impl<T: Sized> Unique<T>

pub const fn dangling() -> Self

Creates a new Unique that is dangling, but well-aligned.

This is useful for initializing types which lazily allocate, like Vec::new does.

Note that the pointer value may potentially represent a valid pointer to a T, which means this must not be used as a “not yet initialized” sentinel value. Types that lazily allocate must track initialization by some other means.

impl<T: ?Sized> Unique<T>

pub const unsafe fn new_unchecked(ptr: *const T) -> Self

Creates a new Unique.

Safety

ptr must be non-null.

pub const fn new(ptr: *const T) -> Option<Self>

Creates a new Unique if ptr is non-null.

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

Acquires the underlying *const pointer.

pub const fn as_non_null_ptr(self) -> NonNull<T>

pub const unsafe fn as_ref(&self) -> &T

Dereferences the content.

The resulting lifetime is bound to self so this behaves “as if” it were actually an instance of T that is getting borrowed. If a longer (unbound) lifetime is needed, use &*my_ptr.as_ptr().

Safety

the caller must guarantee that this object meets all the meets all the requirements for a reference.

pub const fn cast<U>(self) -> Unique<U>

Casts to a pointer of another type.

impl Unique<dirent64>

pub const fn d_ino(self) -> u64

Returns the inode of the dirent64, returns 0 if d_ino is not a struct member on your OS.

pub const fn d_type(self) -> u8

Returns the libc equivalent of the type as eg DT_BLK from libc Follow the link for GNU documentation

Returns DT_UNKNOWN for systems without d_type (eg Solaris/Illumos)

pub fn d_name_slice<'pointer>(self) -> &'pointer [u8]

Returns a slice reference to the d_name, not including null terminator.

pub fn d_name_slice_c_str<'pointer>(self) -> &'pointer CStr

Returns a CStr reference to the d_name, (including null terminator.)

pub const fn d_name(self) -> *const c_char

Access the pointer to d_name, note that d-name is not a [ u8/i8;255] array, it can be greater, So careful attention has to be paid

pub fn name_length(self) -> usize

Returns the length of the d_name but, like strlen, it doesn’t include the null terminator.

Trait Implementations

impl<T: ?Sized> Clone for Unique<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: ?Sized> Debug for Unique<T>

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

Formats the value using the given formatter.

impl<T: ?Sized> From<&mut T> for Unique<T>

fn from(reference: &mut T) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<Unique<T>> for NonNull<T>

fn from(unique: Unique<T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized> Pointer for Unique<T>

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

Formats the value using the given formatter.

impl<T: ?Sized> Copy for Unique<T>

impl<T: Send + ?Sized> Send for Unique<T>

SAFETY: Unique pointers are Send if T is Send because the data they reference is unaliased. Note that this aliasing invariant is unenforced by the type system; the abstraction using the Unique must enforce it.

impl<T: Sync + ?Sized> Sync for Unique<T>

SAFETY: Unique pointers are Sync if T is Sync because the data they reference is unaliased. Note that this aliasing invariant is unenforced by the type system; the abstraction using the Unique must enforce it.