rmp_serialize/
encode.rs

1use std::io::Write;
2
3use rustc_serialize;
4
5use rmp::encode::{write_array_len, write_bool, write_f32, write_f64, write_map_len, write_nil,
6                  write_sint, write_uint, write_str};
7
8use rmp::encode::ValueWriteError;
9
10pub type Error = ValueWriteError;
11
12/// Represents MessagePack serialization implementation.
13///
14/// # Note
15///
16/// MessagePack has no specification about how to encode variant types. Thus we are free to do
17/// whatever we want, so the given chose may be not ideal for you.
18///
19/// Every Rust variant value can be represented as a tuple of index and a value.
20///
21/// All instances of `ErrorKind::Interrupted` are handled by this function and the underlying
22/// operation is retried.
23// TODO: Docs. Examples, variant encoding policy.
24pub struct Encoder<'a> {
25    wr: &'a mut Write,
26}
27
28impl<'a> Encoder<'a> {
29    /// Creates a new MessagePack encoder whose output will be written to the writer specified.
30    pub fn new(wr: &'a mut Write) -> Encoder<'a> {
31        Encoder {
32            wr: wr,
33        }
34    }
35}
36
37impl<'a> rustc_serialize::Encoder for Encoder<'a> {
38    type Error = Error;
39
40    fn emit_nil(&mut self) -> Result<(), Error> {
41        write_nil(&mut self.wr).map_err(|err| ValueWriteError::InvalidMarkerWrite(err))
42    }
43
44    fn emit_bool(&mut self, val: bool) -> Result<(), Error> {
45        write_bool(&mut self.wr, val).map_err(|err| ValueWriteError::InvalidMarkerWrite(err))
46    }
47
48    fn emit_u8(&mut self, val: u8) -> Result<(), Error> {
49        self.emit_u64(val as u64)
50    }
51
52    fn emit_u16(&mut self, val: u16) -> Result<(), Error> {
53        self.emit_u64(val as u64)
54    }
55
56    fn emit_u32(&mut self, val: u32) -> Result<(), Error> {
57        self.emit_u64(val as u64)
58    }
59
60    fn emit_u64(&mut self, val: u64) -> Result<(), Error> {
61        try!(write_uint(&mut self.wr, val));
62        Ok(())
63    }
64
65    fn emit_usize(&mut self, val: usize) -> Result<(), Error> {
66        self.emit_u64(val as u64)
67    }
68
69    fn emit_i8(&mut self, val: i8) -> Result<(), Error> {
70        self.emit_i64(val as i64)
71    }
72
73    fn emit_i16(&mut self, val: i16) -> Result<(), Error> {
74        self.emit_i64(val as i64)
75    }
76
77    fn emit_i32(&mut self, val: i32) -> Result<(), Error> {
78        self.emit_i64(val as i64)
79    }
80
81    fn emit_i64(&mut self, val: i64) -> Result<(), Error> {
82        try!(write_sint(&mut self.wr, val));
83        Ok(())
84    }
85
86    fn emit_isize(&mut self, val: isize) -> Result<(), Error> {
87        self.emit_i64(val as i64)
88    }
89
90    fn emit_f32(&mut self, val: f32) -> Result<(), Error> {
91        write_f32(&mut self.wr, val).map_err(From::from)
92    }
93
94    fn emit_f64(&mut self, val: f64) -> Result<(), Error> {
95        write_f64(&mut self.wr, val).map_err(From::from)
96    }
97
98    // TODO: The implementation involves heap allocation and is unstable.
99    fn emit_char(&mut self, val: char) -> Result<(), Error> {
100        // A char encoded as UTF-8 takes 4 bytes at most.
101        let mut buf = [0; 4];
102        self.emit_str(val.encode_utf8(&mut buf))
103    }
104
105    fn emit_str(&mut self, val: &str) -> Result<(), Error> {
106        write_str(&mut self.wr, val).map_err(From::from)
107    }
108
109    /// Encodes and attempts to write the enum value into the Write.
110    ///
111    /// Currently we encode variant types as a tuple of id with array of args, like: [id, [args...]]
112    fn emit_enum<F>(&mut self, _name: &str, f: F) -> Result<(), Error>
113        where F: FnOnce(&mut Self) -> Result<(), Error>
114    {
115        // Mark that we want to encode a variant type.
116        try!(write_array_len(&mut self.wr, 2));
117
118        // Delegate to the encoder of a concrete value.
119        f(self)
120    }
121
122    /// Encodes and attempts to write a concrete variant value.
123    fn emit_enum_variant<F>(&mut self, _name: &str, id: usize, len: usize, f: F) -> Result<(), Error>
124        where F: FnOnce(&mut Self) -> Result<(), Error>
125    {
126        // Encode a value position...
127        try!(self.emit_usize(id));
128
129        // ... and its arguments length.
130        try!(write_array_len(&mut self.wr, len as u32));
131
132        // Delegate to the encoder of a value args.
133        f(self)
134    }
135
136    /// Encodes and attempts to write a concrete variant value arguments.
137    fn emit_enum_variant_arg<F>(&mut self, _idx: usize, f: F) -> Result<(), Error>
138        where F: FnOnce(&mut Self) -> Result<(), Error>
139    {
140        f(self)
141    }
142
143    fn emit_enum_struct_variant<F>(&mut self, _name: &str, _id: usize, _len: usize, _f: F) -> Result<(), Error>
144        where F: FnOnce(&mut Self) -> Result<(), Error>
145    {
146        unimplemented!()
147    }
148
149    fn emit_enum_struct_variant_field<F>(&mut self, _name: &str, _idx: usize, _f: F) -> Result<(), Error>
150        where F: FnOnce(&mut Self) -> Result<(), Error>
151    {
152        unimplemented!()
153    }
154
155    fn emit_struct<F>(&mut self, _name: &str, len: usize, f: F) -> Result<(), Error>
156        where F: FnOnce(&mut Self) -> Result<(), Error>
157    {
158        self.emit_tuple(len, f)
159    }
160
161    fn emit_struct_field<F>(&mut self, _name: &str, _idx: usize, f: F) -> Result<(), Error>
162        where F: FnOnce(&mut Self) -> Result<(), Error>
163    {
164        f(self)
165    }
166
167    fn emit_tuple<F>(&mut self, len: usize, f: F) -> Result<(), Error>
168        where F: FnOnce(&mut Self) -> Result<(), Error>
169    {
170        try!(write_array_len(&mut self.wr, len as u32));
171        f(self)
172    }
173
174    fn emit_tuple_arg<F>(&mut self, _idx: usize, f: F) -> Result<(), Error>
175        where F: FnOnce(&mut Self) -> Result<(), Error>
176    {
177        f(self)
178    }
179
180    fn emit_tuple_struct<F>(&mut self, _name: &str, len: usize, f: F) -> Result<(), Error>
181        where F: FnOnce(&mut Self) -> Result<(), Error>
182    {
183        self.emit_tuple(len, f)
184    }
185
186    fn emit_tuple_struct_arg<F>(&mut self, _idx: usize, f: F) -> Result<(), Error>
187        where F: FnOnce(&mut Self) -> Result<(), Error>
188    {
189        f(self)
190    }
191
192    fn emit_option<F>(&mut self, f: F) -> Result<(), Error>
193        where F: FnOnce(&mut Self) -> Result<(), Error>
194    {
195        f(self)
196    }
197
198    fn emit_option_none(&mut self) -> Result<(), Error> {
199        self.emit_nil()
200    }
201
202    fn emit_option_some<F>(&mut self, f: F) -> Result<(), Error>
203        where F: FnOnce(&mut Self) -> Result<(), Error>
204    {
205        f(self)
206    }
207
208    // TODO: Check len, overflow is possible.
209    fn emit_seq<F>(&mut self, len: usize, f: F) -> Result<(), Error>
210        where F: FnOnce(&mut Self) -> Result<(), Error>
211    {
212        try!(write_array_len(&mut self.wr, len as u32));
213        f(self)
214    }
215
216    fn emit_seq_elt<F>(&mut self, _idx: usize, f: F) -> Result<(), Error>
217        where F: FnOnce(&mut Self) -> Result<(), Error>
218    {
219        f(self)
220    }
221
222    fn emit_map<F>(&mut self, len: usize, f: F) -> Result<(), Error>
223        where F: FnOnce(&mut Self) -> Result<(), Error>
224    {
225        try!(write_map_len(&mut self.wr, len as u32));
226        f(self)
227    }
228
229    fn emit_map_elt_key<F>(&mut self, _idx: usize, f: F) -> Result<(), Error>
230        where F: FnOnce(&mut Self) -> Result<(), Error>
231    {
232        f(self)
233    }
234
235    fn emit_map_elt_val<F>(&mut self, _idx: usize, f: F) -> Result<(), Error>
236        where F: FnOnce(&mut Self) -> Result<(), Error>
237    {
238        f(self)
239    }
240}
rmp_serialize/encode.rs

rmp_serialize/
encode.rs
