Enum Value 

#[non_exhaustive]
pub enum Value {
    Bool(bool),
    U8(u8),
    I16(i16),
    U16(u16),
    I32(i32),
    U32(u32),
    I64(i64),
    U64(u64),
    F64(f64),
    String(String),
    ObjectPath(ObjectPathBuf),
    Signature(SignatureBuf),
    Array {
        element: SignatureBuf,
        values: Vec<Value>,
    },
    Dict {
        key: SignatureBuf,
        value: SignatureBuf,
        entries: Vec<(Value, Value)>,
    },
    Struct(Vec<Value>),
    Variant(Box<Value>),
}

A D-Bus value whose type is only known at runtime.

This is what a v in a signature is decoded into, and holds the value that was inside the variant rather than the variant itself. A Value::Variant is therefore only produced for a variant nested inside another one.

Examples

use std::collections::HashMap;

use tokio_dbus_runtime::Value;

let mut hints = HashMap::new();
hints.insert(String::from("urgency"), Value::U8(2));
hints.insert(String::from("category"), Value::String("device".into()));

assert_eq!(hints["urgency"].signature()?, "y");
assert_eq!(hints["category"].signature()?, "s");

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Bool(bool)

A boolean.

U8(u8)

A single byte.

I16(i16)

A signed 16-bit integer.

U16(u16)

An unsigned 16-bit integer.

I32(i32)

A signed 32-bit integer.

U32(u32)

An unsigned 32-bit integer.

I64(i64)

A signed 64-bit integer.

U64(u64)

An unsigned 64-bit integer.

F64(f64)

A 64-bit floating point number.

String(String)

A string.

ObjectPath(ObjectPathBuf)

An object path.

Signature(SignatureBuf)

A signature.

Array

An array.

The signature of the element type is carried along, since it cannot be recovered from the values when the array is empty.

Fields

element: SignatureBuf

The type of each element.

values: Vec<Value>

The elements.

Dict

A dictionary, which on the wire is an array of key and value pairs.

Fields

key: SignatureBuf

The type of each key.

value: SignatureBuf

The type of each value.

entries: Vec<(Value, Value)>

The entries, in the order they appeared.

Struct(Vec<Value>)

A struct.

Variant(Box<Value>)

A variant nested inside of another value.

Implementations

impl Value

pub fn array(element: &str) -> Result<Self>

Construct an empty array of the given element type.

Examples

use tokio_dbus_runtime::Value;

let value = Value::array("(iiay)")?;
assert_eq!(value.signature()?, "a(iiay)");

pub fn signature(&self) -> Result<SignatureBuf>

The signature of this value.

Examples

use tokio_dbus_runtime::Value;

let value = Value::Struct(vec![Value::I32(1), Value::String("hi".into())]);
assert_eq!(value.signature()?, "(is)");

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Value

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

Formats the value using the given formatter.

impl Decode for Value

const ALIGNMENT: Alignment = Alignment::BYTE

The alignment of the encoded value.

fn decode(body: &mut Body<'_>) -> Result<Self>

Read one value from the body.

impl Display for Value

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

Formats the value using the given formatter.

impl Encode for Value

const ALIGNMENT: Alignment = Alignment::BYTE

The alignment of the encoded value, which the containers this value is nested inside need in order to pad correctly.

fn encode(&self, raw: &mut Raw<'_>)

Write the value, without writing its signature.

impl PartialEq for Value

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Value