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
mod basic_type;
mod container;
use super::Value;
use crate::{EncodeResult, Encoder};
impl<'a> Encoder<'a> {
pub fn value(&mut self, value: &Value, is_le: bool) -> EncodeResult {
match value {
Value::Byte(b) => {
self.byte(*b);
Ok(())
}
Value::Boolean(b) => {
self.algin(4);
self.boolean(*b, is_le);
Ok(())
}
Value::Int16(i) => {
self.algin(2);
self.int_16(*i, is_le);
Ok(())
}
Value::Uint16(u) => {
self.algin(2);
self.uint_16(*u, is_le);
Ok(())
}
Value::Int32(i) => {
self.algin(4);
self.int_32(*i, is_le);
Ok(())
}
Value::Uint32(u) => {
self.algin(4);
self.uint_32(*u, is_le);
Ok(())
}
Value::Int64(i) => {
self.algin(8);
self.int_64(*i, is_le);
Ok(())
}
Value::Uint64(u) => {
self.algin(8);
self.uint_64(*u, is_le);
Ok(())
}
Value::Double(f) => {
self.algin(8);
self.double(*f, is_le);
Ok(())
}
Value::ObjectPath(s) => {
self.algin(4);
self.path(s, is_le)
}
Value::String(s) => {
self.algin(4);
self.string(s, is_le);
Ok(())
}
Value::Signature(s) => self.signature(s),
Value::Array(vec, sig) => {
self.algin(4);
self.array(vec, sig, is_le)
}
Value::Struct(vec) => {
self.algin(8);
self.encode_struct(vec, is_le)
}
Value::DictEntry(b) => {
self.algin(8);
self.dict_entry(b, is_le)
}
Value::Variant(vec) => self.variant(vec, is_le),
#[cfg(target_family = "unix")]
Value::UnixFD(fd) => {
self.algin(4);
self.unix_fd(*fd, is_le);
Ok(())
}
}
}
}