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
use std::io::Write;
use std::io;
use Argument;
pub struct Message<'a> {
pub path: &'a str,
pub arguments: Vec<Argument<'a>>
}
impl<'a> Message<'a> {
pub fn deserialize(buf: &'a [u8]) -> Result<Message<'a>, ()> {
let mut msg = Message {
path: "",
arguments: vec![]
};
let mut slice = buf;
match Argument::deserialize('s', &mut slice) {
Ok(Argument::s(st)) => msg.path = st,
_ => return Err(())
}
let typetags = match Argument::deserialize('s', &mut slice) {
Ok(Argument::s(st)) => st,
_ => return Err(())
};
if typetags.as_bytes()[0] != (',' as u8) {
return Err(())
}
for typetag in typetags[1 ..].chars() {
let arg = Argument::deserialize(typetag, &mut slice);
match arg {
Ok(arg) => msg.arguments.push(arg),
Err(_) => return Err(())
}
}
Ok(msg)
}
pub fn serialize_into(&self, into: &mut Write) -> io::Result<()> {
try!(Argument::s(self.path).serialize(into));
let mut typetags = String::from(",");
for arg in &self.arguments {
typetags.push(arg.typetag());
}
try!(Argument::s(&*typetags).serialize(into));
for arg in &self.arguments {
try!(arg.serialize(into));
}
Ok(())
}
pub fn serialize(&self) -> io::Result<Vec<u8>> {
let mut ret: Vec<u8> = vec![];
try!(self.serialize_into(&mut ret));
Ok(ret)
}
}