dasl 0.2.0

Data-Adressed Structures & Links
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

use dasl::drisl::{DecodeError, from_slice, to_vec};
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
enum Enum {
    A,
    B,
}

#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
struct EnumStruct {
    e: Enum,
}

#[test]
fn test_enum() {
    let enum_struct = EnumStruct { e: Enum::B };
    let raw = &to_vec(&enum_struct).unwrap();
    println!("raw enum {raw:?}");
    let re: EnumStruct = from_slice(raw).unwrap();
    assert_eq!(enum_struct, re);
}

#[repr(u16)]
#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
enum ReprEnum {
    A,
    B,
}

#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
struct ReprEnumStruct {
    e: ReprEnum,
}

#[test]
fn test_repr_enum() {
    let repr_enum_struct = ReprEnumStruct { e: ReprEnum::B };
    let re: ReprEnumStruct = from_slice(&to_vec(&repr_enum_struct).unwrap()).unwrap();
    assert_eq!(repr_enum_struct, re);
}

#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
enum DataEnum {
    A(u32),
    B(bool, u8),
    C { x: u8, y: String },
}

#[test]
fn test_data_enum() {
    let data_enum_a = DataEnum::A(4);
    let re_a: DataEnum = from_slice(&to_vec(&data_enum_a).unwrap()).unwrap();
    assert_eq!(data_enum_a, re_a);
    let data_enum_b = DataEnum::B(true, 42);
    let re_b: DataEnum = from_slice(&to_vec(&data_enum_b).unwrap()).unwrap();
    assert_eq!(data_enum_b, re_b);
    let data_enum_c = DataEnum::C {
        x: 3,
        y: "foo".to_owned(),
    };
    println!("{:?}", &to_vec(&data_enum_c).unwrap());
    let re_c: DataEnum = from_slice(&to_vec(&data_enum_c).unwrap()).unwrap();
    assert_eq!(data_enum_c, re_c);
}

#[test]
fn test_newtype_struct() {
    #[derive(Debug, Deserialize, Serialize, PartialEq, Eq)]
    pub struct Newtype(u8);
    assert_eq!(to_vec(&142u8).unwrap(), to_vec(&Newtype(142u8)).unwrap());
    assert_eq!(from_slice::<Newtype>(&[24, 142]).unwrap(), Newtype(142));
}

#[derive(Deserialize, PartialEq, Debug)]
enum Foo {
    #[serde(rename = "require")]
    Require,
}

#[test]
fn test_variable_length_array_error() {
    let slice = hex::decode("9F6772657175697265FF").unwrap();
    let value: Result<Vec<Foo>, _> = from_slice(&slice);
    let err = value.unwrap_err();
    assert!(matches!(err, DecodeError::IndefiniteSize), "{err:?}");
}

#[derive(Serialize, Deserialize, PartialEq, Debug)]
enum Bar {
    Empty,
    Number(i32),
    Flag(String, bool),
    Point { x: i32, y: i32 },
}