Struct gvariant::Variant

#[repr(transparent)]
pub struct Variant(_);

The GVariant Variant v type

The Variant type can contain any GVariant value.

Non-spec conformant implementation of Equality with non-normal form data

While every value has a single canoncial byte representation (“normal form”) there other representations that have the same value. For example: values of type (yi) have 3B of padding between the y and the i. In normal form these bytes are 0, but they are irrelevant for the actual value. Ignoring the value of the padding bytes is correct according to the spec.

This is handled correctly when comparing the values of two (yi) instances in rust code. What isn’t correct is the handling of Variant v types that contain non-normal data with respect to checking for equality. Correct checking of equality would require deserialising the data according to the typestr contained within the variant, and then doing the comparison. We don’t do run-time interpretation of typestrs in this crate, prefering to do it at compile time. Instead we just compare the underlying data. This gives correct results for data in normal form, but there will be some false-negatives for non-normal form data.

Therefore Variant implements PartialEq, but not Eq because the comparison is not “reflexive”.

Implementations

impl Variant

pub fn get<M: Marker>(&self, m: M) -> Option<&M::Type> where
    AlignedSlice<A8>: AsAligned<<M::Type as AlignOf>::AlignOf>, 

Get the value from the variant, if it matches the type passed in.

Example:

let a = v.get(gv!("ai"));
// a now has type &[i32]

pub fn split(&self) -> (&[u8], &AlignedSlice<A8>)

Destructures the variant into (typestr, data).

Note: typestr is not guaranteed to be a valid GVariant type.

Example use:

match v.split() {
    (b"(is)", _) => {
        let s = v.get(gv!("(is)"));
        // Do something with s
    }
    (ty, _) => panic!("Unexpected variant type {:?}", ty)
}

Trait Implementations

impl AlignOf for Variant

type AlignOf = A8

impl Cast for Variant

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 Debug for Variant

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

Formats the value using the given formatter.

impl PartialEq<Variant> for Variant

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

Caveat: The current implementation has false negatives for data not in “normal form”. This may change in the future.

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

This method tests for !=.

impl RefCast for Variant

type From = AlignedSlice<A8>

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

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

impl SerializeTo<Variant> for &Variant

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

impl<M: Marker, T: SerializeTo<M::Type>> SerializeTo<Variant> for VariantWrap<M, T>

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

impl ToOwned for Variant

type Owned = Owned<Variant>

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 AllBitPatternsValid for Variant