1pub use message::{Message, LoadableMessage};
2pub use input_stream::{InputStream, Field};
3pub use output_stream::OutputStream;
4pub use serializer::Serializer;
5
6use std::io;
7
8mod message;
9mod input_stream;
10mod output_stream;
11mod output_writer;
12mod serializer;
13mod wire_type;
14
15pub fn load<'a, M: LoadableMessage, R: io::Read>(reader: &mut R) -> io::Result<M> {
16 LoadableMessage::load(reader)
17}
18
19pub fn serializer_for<M: Message>(msg: &M) -> io::Result<Serializer> {
20 let mut serializer = Serializer::new();
21
22 try!(msg.serialize(&mut serializer));
24
25 Ok(serializer)
26}
27
28pub fn serialize<M: Message>(msg: &M) -> io::Result<Vec<u8>> {
29 use std::iter::repeat;
30
31 let serializer = try!(serializer_for(msg));
32 let mut bytes: Vec<u8> = repeat(0).take(serializer.size()).collect();
33
34 try!(serializer.serialize_into(msg, &mut bytes));
35 Ok(bytes)
36}
37
38#[cfg(test)]
39mod test {
40 use std::io;
41 use super::{Message, OutputStream, serialize};
42
43 struct Empty;
44
45 impl Message for Empty {
46 fn serialize<O: OutputStream>(&self, _: &mut O) -> io::Result<()> {
47 Ok(())
48 }
49 }
50
51 #[test]
52 pub fn test_writing_unit_struct() {
53 let bytes = serialize(&Empty).unwrap();
54 assert!(bytes.is_empty());
55 }
56
57 struct Simple;
58
59 impl Message for Simple {
60 fn serialize<O: OutputStream>(&self, out: &mut O) -> io::Result<()> {
61 try!(out.write_str_field(1, "hello"));
62 Ok(())
66 }
67 }
68
69 #[test]
70 pub fn test_writing_simple_message() {
71 let bytes = serialize(&Simple).unwrap();
72 let expect = b"\x0A\x05hello";
73 assert!(bytes == expect, "expect={:?}; actual={:?}", expect, bytes);
74 }
75}