tinyklv 0.1.0

The simplest Key-Length-Value (KLV) framework in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

#![cfg_attr(rustfmt, rustfmt_skip)]
#![allow(clippy::unwrap_used)]
//! See: `book/tutorial/12-default-fallback.md` for full example
use tinyklv::prelude::*;            // Klv proc-macro + traits
use tinyklv::dec::binary as decb;   // binary decoders
use tinyklv::enc::binary as encb;   // binary encoders

#[derive(Debug, PartialEq)]
struct DeviceId(u16);
impl DecodeValue<&[u8]> for DeviceId {
    fn decode_value(input: &mut &[u8]) -> tinyklv::Result<Self> {
        Ok(DeviceId(decb::be_u16(input)?))
    }
}
impl EncodeValue<Vec<u8>> for DeviceId {
    fn encode_value(&self) -> Vec<u8> {
        encb::be_u16(self.0)
    }
}

#[derive(Klv, Debug, PartialEq)]
#[klv(
    stream = &[u8],
    key(dec = decb::u8,          enc = encb::u8),
    len(dec = decb::u8_as_usize, enc = encb::u8_from_usize),
    trait_fallback,
)]
/// Fields lacking `enc` / `dec` fall back to the `EncodeValue` /
/// `DecodeValue` impls on the field type
struct Reading {
    #[klv(key = 0x01)]
    id: DeviceId,

    #[klv(key = 0x02)]
    opt_id: Option<DeviceId>,
}

fn main() {
    // full round-trip through the derived code paths
    let full = Reading {
        id:     DeviceId(0xBEEF),
        opt_id: Some(DeviceId(42)),
    };
    let full_bytes = full.encode_value();
    let full_decoded = Reading::decode_value(
        &mut full_bytes.as_slice(),
    ).unwrap();
    assert_eq!(full_decoded, full);

    // manually constructed stream: only key 0x01 present
    let partial_bytes: &[u8] = &[
        0x01, 0x02, 0xBE, 0xEF,
    ];
    let decoded = Reading::decode_value(
        &mut &partial_bytes[..],
    ).unwrap();
    assert_eq!(decoded.id, DeviceId(0xBEEF));
    assert_eq!(decoded.opt_id, None);
}