Struct OptZero 

pub struct OptZero<T>(/* private fields */)
where
    T: NotZeroable;

Represents an Option where a zero value is considered None.

Wraps an FFI type that SHOULD be non zeroable, and provides a safe way to handle zero values as None

The reason why i used “SHOULD” is because that type may be zeroed if passed from a foreign callsite so extra handling is required, this type makes it safe for it to be zeroed.

Implementations

impl<T> OptZero<T>

where T: NotZeroable,

pub const fn some(x: T) -> OptZero<T>

Creates a new OptZero that represents a Some value from a value.

pub const fn none() -> OptZero<T>

Creates a new OptZero that represents a None value.

pub fn from_option(opt: Option<T>) -> OptZero<T>

Creates a new OptZero from an Option.

pub fn into_option(self) -> Option<T>

Converts this OptZero into an Option.

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

Returns a reference to the contained value or None if the value is zeroed.

pub unsafe fn into_inner_unchecked(self) -> T

Returns the inner value whether or not it is zeroed.

Safety

unsafe because OptZero works with the promise that it is going to handle zeroed values.

pub fn map<F, U>(self, f: F) -> OptZero<U>

where F: FnOnce(T) -> U, U: NotZeroable,

Maps a OptZero to another OptZero using a function.

Trait Implementations

impl<T> Clone for OptZero<T>

where T: Clone + NotZeroable,

fn clone(&self) -> OptZero<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Default for OptZero<T>

where T: Default + NotZeroable,

fn default() -> OptZero<T>

Returns the “default value” for a type.

impl<T> From<Option<T>> for OptZero<T>

where T: NotZeroable,

fn from(value: Option<T>) -> OptZero<T>

Converts to this type from the input type.

impl<T> Hash for OptZero<T>

where T: Hash + NotZeroable,

fn hash<__H>(&self, state: &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> PartialEq for OptZero<T>

where T: NotZeroable + PartialEq,

fn eq(&self, other: &OptZero<T>) -> 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> Copy for OptZero<T>

where T: Copy + NotZeroable,

impl<T> Eq for OptZero<T>

where T: NotZeroable + Eq,