Struct glib::variant::Variant

pub struct Variant(_);

A generic immutable value capable of carrying various types.

See the module documentation for more details.

Implementations

impl Variant

pub fn type_(&self) -> &VariantTy

Returns the type of the value.

pub fn is<T: StaticVariantType>(&self) -> bool

Returns true if the type of the value corresponds to T.

pub fn get<T: FromVariant>(&self) -> Option<T>

Tries to extract a value of type T.

Returns Some if T matches the variant’s type.

pub fn try_get<T: FromVariant>(&self) -> Result<T, VariantTypeMismatchError>

Tries to extract a value of type T.

pub fn from_variant(value: &Variant) -> Self

Boxes value.

pub fn as_variant(&self) -> Option<Variant>

Unboxes self.

Returns Some if self contains a Variant.

pub fn child_value(&self, index: usize) -> Variant

Reads a child item out of a container Variant instance.

Panics

• if self is not a container type.
• if given index is larger than number of children.

pub fn try_child_value(&self, index: usize) -> Option<Variant>

Try to read a child item out of a container Variant instance.

It returns None if self is not a container type or if the given index is larger than number of children.

pub fn try_child_get<T: StaticVariantType + FromVariant>(
    &self,
    index: usize
) -> Result<Option<T>, VariantTypeMismatchError>

Try to read a child item out of a container Variant instance.

It returns Ok(None) if self is not a container type or if the given index is larger than number of children. An error is thrown if the type does not match.

pub fn child_get<T: StaticVariantType + FromVariant>(&self, index: usize) -> T

Read a child item out of a container Variant instance.

Panics

• if self is not a container type.
• if given index is larger than number of children.
• if the expected variant type does not match

pub fn str(&self) -> Option<&str>

Tries to extract a &str.

Returns Some if the variant has a string type (s, o or g type strings).

pub fn bytes(&self) -> Result<&[u8], VariantTypeMismatchError>

Tries to extract a &[u8] from a variant of type ay (array of bytes).

Returns an error if the type is not ay.

pub fn from_array<T: StaticVariantType>(children: &[Variant]) -> Self

Creates a new GVariant array from children.

All children must be of type T.

pub fn from_tuple(children: &[Variant]) -> Self

Creates a new GVariant tuple from children.

pub fn from_maybe<T: StaticVariantType>(child: Option<&Variant>) -> Self

Creates a new maybe Variant.

pub fn from_bytes<T: StaticVariantType>(bytes: &Bytes) -> Self

Constructs a new serialised-mode GVariant instance.

pub unsafe fn from_bytes_trusted<T: StaticVariantType>(bytes: &Bytes) -> Self

Constructs a new serialised-mode GVariant instance.

This is the same as from_bytes, except that checks on the passed data are skipped.

You should not use this function on data from external sources.

Safety

Since the data is not validated, this is potentially dangerous if called on bytes which are not guaranteed to have come from serialising another Variant. The caller is responsible for ensuring bad data is not passed in.

pub fn data_as_bytes(&self) -> Bytes

Returns the serialised form of a GVariant instance.

pub fn normal_form(&self) -> Self

Returns a copy of the variant in normal form.

pub fn byteswap(&self) -> Self

Returns a copy of the variant in the opposite endianness.

pub fn n_children(&self) -> usize

Determines the number of children in a container GVariant instance.

pub fn iter(&self) -> VariantIter

Create an iterator over items in the variant.

Note that this heap allocates a variant for each element, which can be particularly expensive for large arrays.

pub fn array_iter_str(
    &self
) -> Result<VariantStrIter<'_>, VariantTypeMismatchError>

Create an iterator over borrowed strings from a GVariant of type as (array of string).

This will fail if the variant is not an array of with the expected child type.

A benefit of this API over Self::iter() is that it minimizes allocation, and provides strongly typed access.

let strs = &["foo", "bar"];
let strs_variant: glib::Variant = strs.to_variant();
for s in strs_variant.array_iter_str()? {
    println!("{}", s);
}

pub fn is_container(&self) -> bool

Variant has a container type.

Trait Implementations

impl Clone for Variant

fn clone(&self) -> Variant

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Variant

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

Formats the value using the given formatter.

impl Display for Variant

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

Formats the value using the given formatter.

impl From<Variant> for VariantDict

fn from(other: Variant) -> Self

Performs the conversion.

impl FromVariant for Variant

fn from_variant(variant: &Variant) -> Option<Self>

Tries to extract a value.

impl Hash for Variant

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

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

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

fn static_type() -> Type

Returns the type identifier of Self.

impl StaticVariantType for Variant

fn static_variant_type() -> Cow<'static, VariantTy>

Returns the VariantType corresponding to Self.

impl ToVariant for Variant

fn to_variant(&self) -> Variant

Returns a Variant clone of self.

impl Eq for Variant

impl Send for Variant

impl Sync for Variant