Function zvariant::from_slice_for_signature

pub fn from_slice_for_signature<'d, 'r: 'd, B, T: ?Sized>(
    bytes: &'r [u8], 
    ctxt: EncodingContext<B>, 
    signature: &Signature<'_>
) -> Result<T> where
    B: ByteOrder,
    T: Deserialize<'d>, 

Deserialize T from a given slice of bytes with the given signature.

Use this function instead of from_slice if the value being deserialized does not implement Type. Also, if T is an, or (potentially) contains an Fd, use from_slice_fds_for_signature instead.

Examples

One known case where Type implementation isn't possible, is enum types (except simple ones with unit variants only).

use std::convert::TryInto;
use serde::{Deserialize, Serialize};

use zvariant::{to_bytes_for_signature, from_slice_for_signature};
use zvariant::EncodingContext;

#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
enum Test {
    Unit,
    NewType(u8),
    Tuple(u8, u64),
    Struct { y: u8, t: u64 },
}

let ctxt = EncodingContext::<byteorder::LE>::new_dbus(0);
let signature = "u".try_into().unwrap();
let encoded = to_bytes_for_signature(ctxt, &signature, &Test::Unit).unwrap();
let decoded: Test = from_slice_for_signature(&encoded, ctxt, &signature).unwrap();
assert_eq!(decoded, Test::Unit);

let signature = "y".try_into().unwrap();
let encoded = to_bytes_for_signature(ctxt, &signature, &Test::NewType(42)).unwrap();
let decoded: Test = from_slice_for_signature(&encoded, ctxt, &signature).unwrap();
assert_eq!(decoded, Test::NewType(42));

let signature = "(yt)".try_into().unwrap();
let encoded = to_bytes_for_signature(ctxt, &signature, &Test::Tuple(42, 42)).unwrap();
let decoded: Test = from_slice_for_signature(&encoded, ctxt, &signature).unwrap();
assert_eq!(decoded, Test::Tuple(42, 42));

let s = Test::Struct { y: 42, t: 42 };
let encoded = to_bytes_for_signature(ctxt, &signature, &s).unwrap();
let decoded: Test = from_slice_for_signature(&encoded, ctxt, &signature).unwrap();
assert_eq!(decoded, Test::Struct { y: 42, t: 42 });