smdton 0.1.0

Data Tree Object Notation
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use super::sd_node::SmDtonNode;

pub struct ST {}

impl ST {
    // format type
    pub const SMTY_DTR: u8 = 0x01;

    // node type
    pub const SMDT_MAP: u8 = 0x01;
    pub const SMDT_ARR: u8 = 0x02;

    // data type
    pub const SMDT_BOO: u8 = 0x11;
    pub const SMDT_UI8: u8 = 0x12;

    pub const SMDT_I16: u8 = 0x13;
    pub const SMDT_U16: u8 = 0x14; // rare

    pub const SMDT_I32: u8 = 0x15;
    pub const SMDT_U32: u8 = 0x16; // rare
    pub const SMDT_F32: u8 = 0x17; // rare

    pub const SMDT_I64: u8 = 0x18;
    pub const SMDT_U64: u8 = 0x19; // rare
    pub const SMDT_F64: u8 = 0x1a;

    pub const SMDT_STR: u8 = 0x21;
    pub const SMDT_BIN: u8 = 0x22;
}

macro_rules! smd_new_data {
    ($smdt: expr, $len: expr, $has_len: expr, $u: expr, $v: expr) => {
        SmDtonData {
            smdt: $smdt,
            len: $len,
            has_len: $has_len,
            u8a: $u,
            v8a: $v,
            oid: 0,
        }
    };
}

macro_rules! def_func_new {
    ($func_name:ident, $smdt: expr, $len: expr, $dty: ty) => {
        #[allow(dead_code)]
        pub fn $func_name(data: $dty) -> Self {
            let v = data.to_le_bytes().to_vec();
            SmDtonData {
                smdt: $smdt,
                len: $len,
                has_len: false,
                u8a: None,
                v8a: Some(v),
                oid: 0,
            }
        }
    };
}

pub struct SmDtonData<'a> {
    pub smdt: u8,
    pub len: usize,
    pub has_len: bool,
    pub u8a: Option<&'a [u8]>,
    pub v8a: Option<Vec<u8>>,
    pub oid: usize,
}

impl<'a> SmDtonData<'a> {
    #[inline]
    pub fn new_bool(data: bool) -> Self {
        let mut d = 0;
        if data {
            d = 1;
        }
        let v: Vec<u8> = vec![d];
        smd_new_data!(ST::SMDT_BOO, 1, false, None, Some(v))
    }

    #[inline]
    pub fn new_u8(data: u8) -> Self {
        let v: Vec<u8> = vec![data];
        smd_new_data!(ST::SMDT_UI8, 1, false, None, Some(v))
    }

    def_func_new!(new_i16, ST::SMDT_I16, 2, i16);
    def_func_new!(new_u16, ST::SMDT_U16, 2, u16);

    def_func_new!(new_i32, ST::SMDT_I32, 4, i32);
    def_func_new!(new_u32, ST::SMDT_U32, 4, u32);
    def_func_new!(new_f32, ST::SMDT_F32, 4, f32);

    def_func_new!(new_i64, ST::SMDT_I64, 8, i64);
    def_func_new!(new_u64, ST::SMDT_U64, 8, u64);
    def_func_new!(new_f64, ST::SMDT_F64, 8, f64);

    #[inline]
    pub fn new_string(data: &'a str) -> Self {
        let u8a = data.as_bytes();
        smd_new_data!(ST::SMDT_STR, u8a.len() + 1, true, Some(u8a), None)
    }

    #[inline]
    pub fn new_bin(data: &'a [u8]) -> Self {
        smd_new_data!(ST::SMDT_BIN, data.len(), true, Some(data), None)
    }

    #[inline]
    pub fn new_node(data: &SmDtonNode) -> Self {
        SmDtonData {
            smdt: data.smdt,
            len: 0,
            has_len: true,
            u8a: None,
            v8a: None,
            oid: data.oid,
        }
    }
}