Derive Macro glib::Variant

#[derive(Variant)]
{
    // Attributes available to this derive:
    #[variant_enum]
}

Derive macro for serializing/deserializing custom structs/enums as glib::Variants.

Example

use glib::prelude::*;

#[derive(Debug, PartialEq, Eq, glib::Variant)]
struct Foo {
    some_string: String,
    some_int: i32,
}

let v = Foo { some_string: String::from("bar"), some_int: 1 };
let var = v.to_variant();
assert_eq!(var.get::<Foo>(), Some(v));

When storing Vecs of fixed size types it is a good idea to wrap these in glib::FixedSizeVariantArray as serialization/deserialization will be more efficient.

Example

use glib::prelude::*;

#[derive(Debug, PartialEq, Eq, glib::Variant)]
struct Foo {
    some_vec: glib::FixedSizeVariantArray<Vec<u32>, u32>,
    some_int: i32,
}

let v = Foo { some_vec: vec![1u32, 2u32].into(), some_int: 1 };
let var = v.to_variant();
assert_eq!(var.get::<Foo>(), Some(v));

Enums are serialized as a tuple (sv) with the first value as a kebab case string for the enum variant, or just s if this is a C-style enum. Some additional attributes are supported for enums:

• #[variant_enum(repr)] to serialize the enum variant as an integer type instead of s. The #[repr] attribute must also be specified on the enum with a sized integer type, and the type must implement Copy.
• #[variant_enum(enum)] uses EnumClass to serialize/deserialize as nicks. Meant for use with glib::Enum.
• #[variant_enum(flags)] uses FlagsClass to serialize/deserialize as nicks. Meant for use with glib::flags.
• #[variant_enum(enum, repr)] serializes as i32. Meant for use with glib::Enum. The type must also implement Copy.
• #[variant_enum(flags, repr)] serializes as u32. Meant for use with glib::flags.

Example

use glib::prelude::*;

#[derive(Debug, PartialEq, Eq, glib::Variant)]
enum Foo {
    MyA,
    MyB(i32),
    MyC { some_int: u32, some_string: String }
}

let v = Foo::MyC { some_int: 1, some_string: String::from("bar") };
let var = v.to_variant();
assert_eq!(var.child_value(0).str(), Some("my-c"));
assert_eq!(var.get::<Foo>(), Some(v));

#[derive(Debug, Copy, Clone, PartialEq, Eq, glib::Variant)]
#[variant_enum(repr)]
#[repr(u8)]
enum Bar {
    A,
    B = 3,
    C = 7
}

let v = Bar::B;
let var = v.to_variant();
assert_eq!(var.get::<u8>(), Some(3));
assert_eq!(var.get::<Bar>(), Some(v));

#[derive(Debug, Copy, Clone, PartialEq, Eq, glib::Enum, glib::Variant)]
#[variant_enum(enum)]
#[enum_type(name = "MyEnum")]
enum MyEnum {
    Val,
    #[enum_value(name = "My Val")]
    ValWithCustomName,
    #[enum_value(name = "My Other Val", nick = "other")]
    ValWithCustomNameAndNick,
}

let v = MyEnum::ValWithCustomNameAndNick;
let var = v.to_variant();
assert_eq!(var.str(), Some("other"));
assert_eq!(var.get::<MyEnum>(), Some(v));