rmp_serialize/
decode.rs

1use std::error;
2use std::fmt::{self, Display, Formatter};
3use std::io::Read;
4
5use rustc_serialize;
6
7use rmp::Marker;
8use rmp::decode::{ValueReadError, NumValueReadError, DecodeStringError, read_nil, read_bool, read_int, read_f32,
9                  read_f64, read_str_len, read_array_len, read_map_len};
10
11/// Unstable: docs; incomplete
12#[derive(Debug)]
13pub enum Error {
14    InvalidMarkerRead(::std::io::Error),
15    InvalidDataRead(::std::io::Error),
16    /// The actual value type isn't equal with the expected one.
17    TypeMismatch(Marker),
18    OutOfRange,
19    LengthMismatch(u32),
20    /// Uncategorized error.
21    Uncategorized(String),
22}
23
24impl error::Error for Error {
25    fn description(&self) -> &str {
26        "error while decoding value"
27    }
28
29    fn cause(&self) -> Option<&error::Error> {
30        use self::Error::*;
31        match *self {
32            InvalidMarkerRead(ref err) => Some(err),
33            InvalidDataRead(ref err) => Some(err),
34            TypeMismatch(..) => None,
35            OutOfRange => None,
36            LengthMismatch(..) => None,
37            Uncategorized(..) => None,
38        }
39    }
40}
41
42impl Display for Error {
43    fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
44        error::Error::description(self).fmt(f)
45    }
46}
47
48impl From<ValueReadError> for Error {
49    fn from(err: ValueReadError) -> Error {
50        match err {
51            ValueReadError::InvalidMarkerRead(err) => Error::InvalidMarkerRead(err),
52            ValueReadError::InvalidDataRead(err) => Error::InvalidDataRead(err),
53            ValueReadError::TypeMismatch(marker) => Error::TypeMismatch(marker),
54        }
55    }
56}
57
58impl From<NumValueReadError> for Error {
59    fn from(err: NumValueReadError) -> Error {
60        match err {
61            NumValueReadError::InvalidMarkerRead(err) => Error::InvalidMarkerRead(err),
62            NumValueReadError::InvalidDataRead(err) => Error::InvalidDataRead(err),
63            NumValueReadError::TypeMismatch(marker) => Error::TypeMismatch(marker),
64            NumValueReadError::OutOfRange => Error::OutOfRange,
65        }
66    }
67}
68
69/// Unstable: docs; incomplete
70impl<'a> From<DecodeStringError<'a>> for Error {
71    fn from(err: DecodeStringError) -> Error {
72        match err {
73            DecodeStringError::InvalidMarkerRead(err) => Error::InvalidMarkerRead(err),
74            DecodeStringError::InvalidDataRead(..) => {
75                Error::Uncategorized("InvalidDataRead".to_string())
76            }
77            DecodeStringError::TypeMismatch(..) => Error::Uncategorized("TypeMismatch".to_string()),
78            DecodeStringError::BufferSizeTooSmall(..) => {
79                Error::Uncategorized("BufferSizeTooSmall".to_string())
80            }
81            DecodeStringError::InvalidUtf8(..) => Error::Uncategorized("InvalidUtf8".to_string()),
82        }
83    }
84}
85
86/// # Note
87///
88/// All instances of `ErrorKind::Interrupted` are handled by this function and the underlying
89/// operation is retried.
90// TODO: Docs. Examples.
91pub struct Decoder<R: Read> {
92    rd: R,
93}
94
95impl<R: Read> Decoder<R> {
96    // TODO: Docs.
97    pub fn new(rd: R) -> Decoder<R> {
98        Decoder { rd: rd }
99    }
100
101    /// Gets a reference to the underlying reader in this decoder.
102    pub fn get_ref(&self) -> &R {
103        &self.rd
104    }
105
106    /// Gets a mutable reference to the underlying reader in this decoder.
107    pub fn get_mut(&mut self) -> &mut R {
108        &mut self.rd
109    }
110
111    /// Consumes this decoder returning the underlying reader.
112    pub fn into_inner(self) -> R {
113        self.rd
114    }
115}
116
117/// Unstable: docs; examples; incomplete
118impl<R: Read> rustc_serialize::Decoder for Decoder<R> {
119    type Error = Error;
120
121    fn read_nil(&mut self) -> Result<(), Error> {
122        Ok(try!(read_nil(&mut self.rd)))
123    }
124
125    fn read_bool(&mut self) -> Result<bool, Error> {
126        Ok(try!(read_bool(&mut self.rd)))
127    }
128
129    fn read_u8(&mut self) -> Result<u8, Error> {
130        Ok(try!(read_int(&mut self.rd)))
131    }
132
133    fn read_u16(&mut self) -> Result<u16, Error> {
134        Ok(try!(read_int(&mut self.rd)))
135    }
136
137    fn read_u32(&mut self) -> Result<u32, Error> {
138        Ok(try!(read_int(&mut self.rd)))
139    }
140
141    fn read_u64(&mut self) -> Result<u64, Error> {
142        Ok(try!(read_int(&mut self.rd)))
143    }
144
145    fn read_usize(&mut self) -> Result<usize, Error> {
146        Ok(try!(read_int(&mut self.rd)))
147    }
148
149    fn read_i8(&mut self) -> Result<i8, Error> {
150        Ok(try!(read_int(&mut self.rd)))
151    }
152
153    fn read_i16(&mut self) -> Result<i16, Error> {
154        Ok(try!(read_int(&mut self.rd)))
155    }
156
157    fn read_i32(&mut self) -> Result<i32, Error> {
158        Ok(try!(read_int(&mut self.rd)))
159    }
160
161    fn read_i64(&mut self) -> Result<i64, Error> {
162        Ok(try!(read_int(&mut self.rd)))
163    }
164
165    fn read_isize(&mut self) -> Result<isize, Error> {
166        Ok(try!(read_int(&mut self.rd)))
167    }
168
169    fn read_f32(&mut self) -> Result<f32, Error> {
170        Ok(try!(read_f32(&mut self.rd)))
171    }
172
173    fn read_f64(&mut self) -> Result<f64, Error> {
174        Ok(try!(read_f64(&mut self.rd)))
175    }
176
177    fn read_char(&mut self) -> Result<char, Error> {
178        let mut res = try!(self.read_str());
179        if res.len() == 1 {
180            Ok(res.pop().unwrap())
181        } else {
182            Err(self.error("length mismatch"))
183        }
184    }
185
186    fn read_str(&mut self) -> Result<String, Error> {
187        let len = try!(read_str_len(&mut self.rd));
188
189        let mut buf: Vec<u8> = vec![0u8; len as usize];
190
191        try!(self.rd.read_exact(&mut buf).map_err(|err| Error::InvalidDataRead(err)));
192
193        String::from_utf8(buf).map_err(|err| Error::Uncategorized(format!("{}", err)))
194    }
195
196    fn read_enum<T, F>(&mut self, _name: &str, f: F) -> Result<T, Error>
197        where F: FnOnce(&mut Self) -> Result<T, Error>
198    {
199        let len = try!(read_array_len(&mut self.rd));
200        if len == 2 {
201            f(self)
202        } else {
203            Err(self.error("sequence length mismatch"))
204        }
205    }
206
207    fn read_enum_variant<T, F>(&mut self, names: &[&str], mut f: F) -> Result<T, Error>
208        where F: FnMut(&mut Self, usize) -> Result<T, Error>
209    {
210        let id = try!(self.read_usize());
211
212        if id < names.len() {
213            try!(read_array_len(&mut self.rd));
214
215            f(self, id)
216        } else {
217            Err(self.error("variant type overflow"))
218        }
219    }
220
221    fn read_enum_variant_arg<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error>
222        where F: FnOnce(&mut Self) -> Result<T, Error>
223    {
224        f(self)
225    }
226
227    fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> Result<T, Error>
228        where F: FnMut(&mut Self, usize) -> Result<T, Error>
229    {
230        self.read_enum_variant(names, f)
231    }
232
233    fn read_enum_struct_variant_field<T, F>(&mut self, _name: &str, _idx: usize, f: F) -> Result<T, Error>
234        where F: FnOnce(&mut Self) -> Result<T, Error>
235    {
236        f(self)
237    }
238
239    fn read_struct<T, F>(&mut self, _name: &str, len: usize, f: F) -> Result<T, Error>
240        where F: FnOnce(&mut Self) -> Result<T, Error>
241    {
242        self.read_tuple(len, f)
243    }
244
245    fn read_struct_field<T, F>(&mut self, _name: &str, _idx: usize, f: F) -> Result<T, Error>
246        where F: FnOnce(&mut Self) -> Result<T, Error>
247    {
248        f(self)
249    }
250
251    fn read_tuple<T, F>(&mut self, len: usize, f: F) -> Result<T, Error>
252        where F: FnOnce(&mut Self) -> Result<T, Error>
253    {
254        let actual = try!(read_array_len(&mut self.rd));
255
256        if len == actual as usize {
257            f(self)
258        } else {
259            Err(Error::LengthMismatch(actual))
260        }
261    }
262
263    // In case of MessagePack don't care about argument indexing.
264    fn read_tuple_arg<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error>
265        where F: FnOnce(&mut Self) -> Result<T, Error>
266    {
267        f(self)
268    }
269
270    fn read_tuple_struct<T, F>(&mut self, _name: &str, _len: usize, _f: F) -> Result<T, Error>
271        where F: FnOnce(&mut Self) -> Result<T, Error>
272    {
273        unimplemented!()
274    }
275    fn read_tuple_struct_arg<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error>
276        where F: FnOnce(&mut Self) -> Result<T, Error>
277    {
278        unimplemented!()
279    }
280
281    /// We treat Value::Null as None.
282    fn read_option<T, F>(&mut self, mut f: F) -> Result<T, Error>
283        where F: FnMut(&mut Self, bool) -> Result<T, Error>
284    {
285        // Primarily try to read optimisticly.
286        match f(self, true) {
287            Ok(val) => Ok(val),
288            Err(Error::TypeMismatch(Marker::Null)) => f(self, false),
289            Err(err) => Err(err),
290        }
291    }
292
293    fn read_seq<T, F>(&mut self, f: F) -> Result<T, Error>
294        where F: FnOnce(&mut Self, usize) -> Result<T, Error>
295    {
296        let len = try!(read_array_len(&mut self.rd)) as usize;
297
298        f(self, len)
299    }
300
301    fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error>
302        where F: FnOnce(&mut Self) -> Result<T, Error>
303    {
304        f(self)
305    }
306
307    fn read_map<T, F>(&mut self, f: F) -> Result<T, Error>
308        where F: FnOnce(&mut Self, usize) -> Result<T, Error>
309    {
310        let len = try!(read_map_len(&mut self.rd)) as usize;
311
312        f(self, len)
313    }
314
315    fn read_map_elt_key<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error>
316        where F: FnOnce(&mut Self) -> Result<T, Error>
317    {
318        f(self)
319    }
320
321    fn read_map_elt_val<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error>
322        where F: FnOnce(&mut Self) -> Result<T, Error>
323    {
324        f(self)
325    }
326
327    fn error(&mut self, err: &str) -> Error {
328        Error::Uncategorized(err.to_string())
329    }
330}
rmp_serialize/decode.rs

rmp_serialize/
decode.rs
