Struct zvariant::DictEntry

pub struct DictEntry { /* fields omitted */ }

A dictionary entry as a key-value pair.

This is not very useful on its own but since D-Bus defines it as its own type, a hashmap in D-Bus is encoded as an array of dictionary entries and GVariant even allows this to be used outside of an array, we provide this data type.

The key must be a basic data type.

Example:

use zvariant::{Decode, DictEntry};
use zvariant::{Encode, EncodingFormat, Structure};

let entry = DictEntry::new(
    // String key
    "hello",
    // Structure value
    Structure::new()
        .add_field(u8::max_value())
        .add_field(u32::max_value()),
);
assert!(entry.signature() == "{s(yu)}");

let format = EncodingFormat::default();
let encoding = entry.encode(format);
assert!(encoding.len() == 24);

let entry = DictEntry::decode(encoding, entry.signature(), format).unwrap();
assert!(entry.key::<String>().unwrap() == "hello");
let structure = entry.value::<Structure>().unwrap();
let fields = structure.fields();
assert!(u8::is(&fields[0]));
assert!(*u8::from_variant(&fields[0]).unwrap() == u8::max_value());
assert!(u32::is(&fields[1]));
assert!(*u32::from_variant(&fields[1]).unwrap() == u32::max_value());

Methods

impl DictEntry

pub fn new<K, V>(key: K, value: V) -> Self where
    K: Encode + Basic,
    V: Encode, 

Create a new DictEntry

pub fn key<K>(&self) -> Result<&K, VariantError> where
    K: Decode + Basic, 

Get a reference to the key.

pub fn value<V>(&self) -> Result<&V, VariantError> where
    V: Decode, 

Get a reference to the value.

pub fn take<K, V>(self) -> Result<(K, V), VariantError> where
    K: Decode + Basic,
    V: Decode, 

Take the key and value, consuming self.

Trait Implementations

impl Clone for DictEntry

fn clone(&self) -> DictEntry

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DictEntry

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

Formats the value using the given formatter.

impl Decode for DictEntry

fn slice_data(
    data: impl Into<SharedData>,
    signature: impl Into<Signature>,
    format: EncodingFormat
) -> Result<SharedData, VariantError>

Get the slice of data that belongs to implementing type.

fn decode(
    data: impl Into<SharedData>,
    signature: impl Into<Signature>,
    format: EncodingFormat
) -> Result<Self, VariantError>

Decode instance of implementing type from the data slice.

fn ensure_correct_signature(
    signature: impl Into<Signature>
) -> Result<Signature, VariantError>

Ensure given signature is correct and of the implementing type.

fn slice_signature(
    signature: impl Into<Signature>
) -> Result<Signature, VariantError>

Get the slice of signature that belongs to implementing type.

fn take_from_variant(variant: Variant) -> Result<Self, VariantError>

Flatten the variant to enclosed value of the implementing type.

fn from_variant(variant: &Variant) -> Result<&Self, VariantError>

Flatten the variant reference to a reference of the enclosed value of the implementing type.

fn slice_for_decoding(
    data: impl Into<SharedData>,
    signature: impl Into<Signature>,
    format: EncodingFormat
) -> Result<SharedData, VariantError>

A helper for [decode] implementation. Removes any leading padding bytes.

impl Encode for DictEntry

const SIGNATURE_CHAR: char

The signature charachter of the implementing type.

const SIGNATURE_STR: &'static str

The signature charachter of the implementing type, in string format.

const ALIGNMENT: usize

The alignment required for encoding of the implementing type, as number of bytes.

fn encode_into(&self, bytes: &mut Vec<u8>, format: EncodingFormat)

Encode self and append to the end of bytes buffer.

fn signature(&self) -> Signature

Get the signature.

fn to_variant(self) -> Variant

Unflatten self into a [Variant].

fn is(variant: &Variant) -> bool

Checks if variant value is of the generic type T.

fn encode(&self, format: EncodingFormat) -> Vec<u8>

Encode self into a new byte buffer and return it.

fn add_padding(bytes: &mut Vec<u8>, format: EncodingFormat)

Append required padding to bytes buffer.

fn padding(n_bytes_before: usize, _format: EncodingFormat) -> usize

The required padding for the implementing type.