Struct gvariant::MaybeFixedSize

#[repr(transparent)]
pub struct MaybeFixedSize<T: Cast> { /* private fields */ }

Type with same representation as GVariant “mX” type where X is any fixed size type

This is the type returned by:

gv!("mb").cast(data);
gv!("mi").cast(data);
gv!("m(yi)").cast(data);

Rust’s built in Option doesn’t have any specified byte representation so we need our own type here.

Maybes are encoded differently depending on if their element type is fixed-sized or not. MaybeNonFixedSize is used when the contained size is non-fixed, but it implements the same interface as this type

You probably just want to call .to_option() on this type.

Implementations

impl<T: Cast> MaybeFixedSize<T>

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

Convert to a rust native Option type.

Note: this doesn’t copy the data, it returns an option to a reference to the underlying data.

Trait Implementations

impl<T: Cast> AlignOf for MaybeFixedSize<T>

type AlignOf = <T as AlignOf>::AlignOf

impl<T: Cast> Cast for MaybeFixedSize<T>

fn default_ref() -> &'static Self

Get a static reference to the default value for this type.

fn try_from_aligned_slice(
    slice: &AlignedSlice<Self::AlignOf>
) -> Result<&Self, WrongSize>

fn try_from_aligned_slice_mut(
    slice: &mut AlignedSlice<Self::AlignOf>
) -> Result<&mut Self, WrongSize>

fn from_aligned_slice(slice: &AlignedSlice<Self::AlignOf>) -> &Self

Cast slice to type Self.

impl<T: Cast + Debug> Debug for MaybeFixedSize<T>

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

Formats the value using the given formatter.

impl<'a, T: Cast> From<&'a MaybeFixedSize<T>> for Option<&'a T>

fn from(m: &'a MaybeFixedSize<T>) -> Self

Converts to this type from the input type.

impl<T: Cast + Hash> Hash for MaybeFixedSize<T>

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, 

Feeds a slice of this type into the given Hasher.

impl<'a, T: Cast> IntoIterator for &'a MaybeFixedSize<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = IntoIter<&'a T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Cast + PartialEq> PartialEq<&'_ MaybeFixedSize<T>> for Option<&T>

fn eq(&self, other: &&MaybeFixedSize<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl<T: Cast + PartialEq> PartialEq<MaybeFixedSize<T>> for MaybeFixedSize<T>

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl<T: Cast + PartialEq> PartialEq<Option<&'_ T>> for &MaybeFixedSize<T>

fn eq(&self, other: &Option<&T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl<T: Cast + PartialOrd> PartialOrd<MaybeFixedSize<T>> for MaybeFixedSize<T>

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl<T: Cast> RefCast for MaybeFixedSize<T>

type From = AlignedSlice<<T as AlignOf>::AlignOf>

fn ref_cast(_from: &Self::From) -> &Self

fn ref_cast_mut(_from: &mut Self::From) -> &mut Self

impl<'a, GvT: Cast + SerializeTo<GvT>> SerializeTo<MaybeFixedSize<GvT>> for &'a MaybeFixedSize<GvT> where
    &'a GvT: SerializeTo<GvT>, 

fn serialize(self, f: &mut impl Write) -> Result<usize>

impl<GvT: Cast, T: SerializeTo<GvT> + Copy> SerializeTo<MaybeFixedSize<GvT>> for &Option<T> where
    T: SerializeTo<GvT>, 

fn serialize(self, f: &mut impl Write) -> Result<usize>

impl<T: Cast> ToOwned for MaybeFixedSize<T>

type Owned = Owned<MaybeFixedSize<T>>

The resulting type after obtaining ownership.

fn to_owned(&self) -> Self::Owned

Creates owned data from borrowed data, usually by cloning.

fn clone_into(&self, target: &mut Self::Owned)

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

Uses borrowed data to replace owned data, usually by cloning.

impl<T: Cast> AllBitPatternsValid for MaybeFixedSize<T>

impl<T: Cast + Eq> Eq for MaybeFixedSize<T>