Trait Decode 

pub trait Decode: Sized {
    const ALIGNMENT: Alignment;

    // Required method
    fn decode(body: &mut Body<'_>) -> Result<Self>;
}

A Rust value which can be read from a D-Bus message body.

Examples

use tokio_dbus::{BodyBuf, Signature};
use tokio_dbus_runtime::Decode;

let mut buf = BodyBuf::new();
buf.extend_signature(Signature::new("su")?)?;
buf.raw().store("Hello");
buf.raw().store(42u32);

let mut body = buf.as_body();
assert_eq!(String::decode(&mut body)?, "Hello");
assert_eq!(u32::decode(&mut body)?, 42);

Required Associated Constants

const ALIGNMENT: Alignment

The alignment of the encoded value.

Required Methods

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

Read one value from the body.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl Decode for ObjectPathBuf

const ALIGNMENT: Alignment = Alignment::U32

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

impl Decode for SignatureBuf

const ALIGNMENT: Alignment = Alignment::BYTE

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

impl Decode for String

const ALIGNMENT: Alignment = Alignment::U32

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

impl Decode for bool

const ALIGNMENT: Alignment = Alignment::U32

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

impl Decode for f64

const ALIGNMENT: Alignment = Alignment::U64

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

impl Decode for i16

const ALIGNMENT: Alignment = Alignment::U16

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

impl Decode for i32

const ALIGNMENT: Alignment = Alignment::U32

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

impl Decode for i64

const ALIGNMENT: Alignment = Alignment::U64

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

impl Decode for u8

const ALIGNMENT: Alignment = Alignment::BYTE

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

impl Decode for u16

const ALIGNMENT: Alignment = Alignment::U16

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

impl Decode for u32

const ALIGNMENT: Alignment = Alignment::U32

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

impl Decode for u64

const ALIGNMENT: Alignment = Alignment::U64

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

impl<A, B, C, D, E, F, G, H, I, J, K, L> Decode for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: Decode, B: Decode, C: Decode, D: Decode, E: Decode, F: Decode, G: Decode, H: Decode, I: Decode, J: Decode, K: Decode, L: Decode,

const ALIGNMENT: Alignment = Alignment::U64

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

impl<A, B, C, D, E, F, G, H, I, J, K> Decode for (A, B, C, D, E, F, G, H, I, J, K)

where A: Decode, B: Decode, C: Decode, D: Decode, E: Decode, F: Decode, G: Decode, H: Decode, I: Decode, J: Decode, K: Decode,

const ALIGNMENT: Alignment = Alignment::U64

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

impl<A, B, C, D, E, F, G, H, I, J> Decode for (A, B, C, D, E, F, G, H, I, J)

where A: Decode, B: Decode, C: Decode, D: Decode, E: Decode, F: Decode, G: Decode, H: Decode, I: Decode, J: Decode,

const ALIGNMENT: Alignment = Alignment::U64

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

impl<A, B, C, D, E, F, G, H, I> Decode for (A, B, C, D, E, F, G, H, I)

where A: Decode, B: Decode, C: Decode, D: Decode, E: Decode, F: Decode, G: Decode, H: Decode, I: Decode,

const ALIGNMENT: Alignment = Alignment::U64

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

impl<A, B, C, D, E, F, G, H> Decode for (A, B, C, D, E, F, G, H)

where A: Decode, B: Decode, C: Decode, D: Decode, E: Decode, F: Decode, G: Decode, H: Decode,

const ALIGNMENT: Alignment = Alignment::U64

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

impl<A, B, C, D, E, F, G> Decode for (A, B, C, D, E, F, G)

where A: Decode, B: Decode, C: Decode, D: Decode, E: Decode, F: Decode, G: Decode,

const ALIGNMENT: Alignment = Alignment::U64

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

impl<A, B, C, D, E, F> Decode for (A, B, C, D, E, F)

where A: Decode, B: Decode, C: Decode, D: Decode, E: Decode, F: Decode,

const ALIGNMENT: Alignment = Alignment::U64

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

impl<A, B, C, D, E> Decode for (A, B, C, D, E)

where A: Decode, B: Decode, C: Decode, D: Decode, E: Decode,

const ALIGNMENT: Alignment = Alignment::U64

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

impl<A, B, C, D> Decode for (A, B, C, D)

where A: Decode, B: Decode, C: Decode, D: Decode,

const ALIGNMENT: Alignment = Alignment::U64

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

impl<A, B, C> Decode for (A, B, C)

where A: Decode, B: Decode, C: Decode,

const ALIGNMENT: Alignment = Alignment::U64

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

impl<A, B> Decode for (A, B)

where A: Decode, B: Decode,

const ALIGNMENT: Alignment = Alignment::U64

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

impl<A> Decode for (A,)

where A: Decode,

const ALIGNMENT: Alignment = Alignment::U64

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

impl<K, V, S> Decode for HashMap<K, V, S>

where K: Decode + Eq + Hash, V: Decode, S: Default + BuildHasher,

const ALIGNMENT: Alignment = Alignment::U32

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

impl<K, V> Decode for BTreeMap<K, V>

where K: Decode + Ord, V: Decode,

const ALIGNMENT: Alignment = Alignment::U32

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

impl<T> Decode for Vec<T>

where T: Decode,

const ALIGNMENT: Alignment = Alignment::U32

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

Implementors

impl Decode for Value

const ALIGNMENT: Alignment = Alignment::BYTE