1 /// Deserialization module.
2 ///
3
4 pub use self::error::{Error, ParseError, Result};
5
6 use std::borrow::Cow;
7 use std::io;
8 use std::str;
9
10 use serde::de::{self, Deserializer as Deserializer_, DeserializeSeed, Visitor};
11
12 use parse::Bytes;
13 use self::id::IdDeserializer;
14
15 mod error;
16 mod id;
17 #[cfg(test)]
18 mod tests;
19 mod value;
20
21 /// The RON deserializer.
22 ///
23 /// If you just want to simply deserialize a value,
24 /// you can use the `from_str` convenience function.
25 pub struct Deserializer<'de> {
26 bytes: Bytes<'de>,
27 }
28
29 impl<'de> Deserializer<'de> {
from_str(input: &'de str) -> Self30 pub fn from_str(input: &'de str) -> Self {
31 Deserializer {
32 bytes: Bytes::new(input.as_bytes()),
33 }
34 }
35
from_bytes(input: &'de [u8]) -> Self36 pub fn from_bytes(input: &'de [u8]) -> Self {
37 Deserializer {
38 bytes: Bytes::new(input),
39 }
40 }
41
remainder(&self) -> Cow<str>42 pub fn remainder(&self) -> Cow<str> {
43 String::from_utf8_lossy(&self.bytes.bytes())
44 }
45 }
46
47 /// A convenience function for reading data from a reader
48 /// and feeding into a deserializer
from_reader<R, T>(mut rdr: R) -> Result<T> where R: io::Read, T: de::DeserializeOwned49 pub fn from_reader<R, T>(mut rdr: R) -> Result<T>
50 where R: io::Read,
51 T: de::DeserializeOwned
52 {
53 let mut bytes = Vec::new();
54 rdr.read_to_end(&mut bytes)?;
55 let s = str::from_utf8(&bytes)?;
56 from_str(s)
57 }
58
59 /// A convenience function for building a deserializer
60 /// and deserializing a value of type `T`.
from_str<'a, T>(s: &'a str) -> Result<T> where T: de::Deserialize<'a>61 pub fn from_str<'a, T>(s: &'a str) -> Result<T>
62 where T: de::Deserialize<'a>
63 {
64 let mut deserializer = Deserializer::from_str(s);
65 let t = T::deserialize(&mut deserializer)?;
66
67 deserializer.end()?;
68
69 Ok(t)
70 }
71
72 impl<'de> Deserializer<'de> {
73 /// Check if the remaining bytes are whitespace only,
74 /// otherwise return an error.
end(&mut self) -> Result<()>75 pub fn end(&mut self) -> Result<()> {
76 self.bytes.skip_ws();
77
78 if self.bytes.bytes().is_empty() {
79 Ok(())
80 } else {
81 self.bytes.err(ParseError::TrailingCharacters)
82 }
83 }
84 }
85
86 impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
87 type Error = Error;
88
deserialize_any<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>89 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
90 where V: Visitor<'de>
91 {
92 if self.bytes.consume_ident("true") {
93 return visitor.visit_bool(true);
94 } else if self.bytes.consume_ident("false") {
95 return visitor.visit_bool(false);
96 } else if self.bytes.check_ident("Some") {
97 return self.deserialize_option(visitor);
98 } else if self.bytes.consume_ident("None") {
99 return visitor.visit_none();
100 } else if self.bytes.consume("()") {
101 return visitor.visit_unit();
102 }
103
104 if self.bytes.identifier().is_ok() {
105 self.bytes.skip_ws();
106
107 return self.deserialize_struct("", &[], visitor);
108 }
109
110 match self.bytes.peek_or_eof()? {
111 b'(' => self.deserialize_struct("", &[], visitor),
112 b'[' => self.deserialize_seq(visitor),
113 b'{' => self.deserialize_map(visitor),
114 b'0' ... b'9' | b'+' | b'-' | b'.' => self.deserialize_f64(visitor),
115 b'"' => self.deserialize_string(visitor),
116 b'\'' => self.deserialize_char(visitor),
117 other => self.bytes.err(ParseError::UnexpectedByte(other as char)),
118 }
119 }
120
deserialize_bool<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>121 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
122 where V: Visitor<'de>
123 {
124 visitor.visit_bool(self.bytes.bool()?)
125 }
126
deserialize_i8<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>127 fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
128 where V: Visitor<'de>
129 {
130 visitor.visit_i8(self.bytes.signed_integer()?)
131 }
132
deserialize_i16<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>133 fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
134 where V: Visitor<'de>
135 {
136 visitor.visit_i16(self.bytes.signed_integer()?)
137 }
138
deserialize_i32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>139 fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
140 where V: Visitor<'de>
141 {
142 visitor.visit_i32(self.bytes.signed_integer()?)
143 }
144
deserialize_i64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>145 fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
146 where V: Visitor<'de>
147 {
148 visitor.visit_i64(self.bytes.signed_integer()?)
149 }
150
deserialize_u8<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>151 fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
152 where V: Visitor<'de>
153 {
154 visitor.visit_u8(self.bytes.unsigned_integer()?)
155 }
156
deserialize_u16<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>157 fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
158 where V: Visitor<'de>
159 {
160 visitor.visit_u16(self.bytes.unsigned_integer()?)
161 }
162
deserialize_u32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>163 fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
164 where V: Visitor<'de>
165 {
166 visitor.visit_u32(self.bytes.unsigned_integer()?)
167 }
168
deserialize_u64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>169 fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
170 where V: Visitor<'de>
171 {
172 visitor.visit_u64(self.bytes.unsigned_integer()?)
173 }
174
deserialize_f32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>175 fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
176 where V: Visitor<'de>
177 {
178 visitor.visit_f32(self.bytes.float()?)
179 }
180
deserialize_f64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>181 fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
182 where V: Visitor<'de>
183 {
184 visitor.visit_f64(self.bytes.float()?)
185 }
186
deserialize_char<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>187 fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
188 where V: Visitor<'de>
189 {
190 visitor.visit_char(self.bytes.char()?)
191 }
192
deserialize_str<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>193 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
194 where V: Visitor<'de>
195 {
196 use parse::ParsedStr;
197
198 match self.bytes.string()? {
199 ParsedStr::Allocated(s) => visitor.visit_string(s),
200 ParsedStr::Slice(s) => visitor.visit_str(s),
201 }
202 }
203
deserialize_string<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>204 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
205 where V: Visitor<'de>
206 {
207 self.deserialize_str(visitor)
208 }
209
deserialize_bytes<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>210 fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
211 where V: Visitor<'de>
212 {
213 self.deserialize_seq(visitor)
214 }
215
deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>216 fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
217 where V: Visitor<'de>
218 {
219 self.deserialize_seq(visitor)
220 }
221
deserialize_option<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>222 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
223 where V: Visitor<'de>
224 {
225 if self.bytes.consume("Some") && { self.bytes.skip_ws(); self.bytes.consume("(") } {
226 self.bytes.skip_ws();
227
228 let v = visitor.visit_some(&mut *self)?;
229
230 self.bytes.skip_ws();
231
232 if self.bytes.consume(")") {
233 Ok(v)
234 } else {
235 self.bytes.err(ParseError::ExpectedOptionEnd)
236 }
237
238 } else if self.bytes.consume("None") {
239 visitor.visit_none()
240 } else {
241 self.bytes.err(ParseError::ExpectedOption)
242 }
243 }
244
245 // In Serde, unit means an anonymous value containing no data.
deserialize_unit<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>246 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
247 where V: Visitor<'de>
248 {
249 if self.bytes.consume("()") {
250 visitor.visit_unit()
251 } else {
252 self.bytes.err(ParseError::ExpectedUnit)
253 }
254 }
255
deserialize_unit_struct<V>( self, name: &'static str, visitor: V ) -> Result<V::Value> where V: Visitor<'de>256 fn deserialize_unit_struct<V>(
257 self,
258 name: &'static str,
259 visitor: V
260 ) -> Result<V::Value>
261 where V: Visitor<'de>
262 {
263 if self.bytes.consume(name) {
264 visitor.visit_unit()
265 } else {
266 self.deserialize_unit(visitor)
267 }
268 }
269
deserialize_newtype_struct<V>( self, name: &'static str, visitor: V ) -> Result<V::Value> where V: Visitor<'de>270 fn deserialize_newtype_struct<V>(
271 self,
272 name: &'static str,
273 visitor: V
274 ) -> Result<V::Value>
275 where V: Visitor<'de>
276 {
277 self.bytes.consume(name);
278
279 self.bytes.skip_ws();
280
281 if self.bytes.consume("(") {
282 let value = visitor.visit_newtype_struct(&mut *self)?;
283 self.bytes.comma();
284
285 if self.bytes.consume(")") {
286 Ok(value)
287 } else {
288 self.bytes.err(ParseError::ExpectedStructEnd)
289 }
290 } else {
291 self.bytes.err(ParseError::ExpectedStruct)
292 }
293 }
294
deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value> where V: Visitor<'de>295 fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value>
296 where V: Visitor<'de>
297 {
298 if self.bytes.consume("[") {
299 let value = visitor.visit_seq(CommaSeparated::new(b']', &mut self))?;
300 self.bytes.comma();
301
302 if self.bytes.consume("]") {
303 Ok(value)
304 } else {
305 self.bytes.err(ParseError::ExpectedArrayEnd)
306 }
307 } else {
308 self.bytes.err(ParseError::ExpectedArray)
309 }
310 }
311
312 // Tuples look just like sequences in JSON. Some formats may be able to
313 // represent tuples more efficiently.
314 //
315 // As indicated by the length parameter, the `Deserialize` implementation
316 // for a tuple in the Serde data model is required to know the length of the
317 // tuple before even looking at the input data.
deserialize_tuple<V>( mut self, _len: usize, visitor: V ) -> Result<V::Value> where V: Visitor<'de>318 fn deserialize_tuple<V>(
319 mut self,
320 _len: usize,
321 visitor: V
322 ) -> Result<V::Value>
323 where V: Visitor<'de>
324 {
325 if self.bytes.consume("(") {
326 let value = visitor.visit_seq(CommaSeparated::new(b')', &mut self))?;
327 self.bytes.comma();
328
329 if self.bytes.consume(")") {
330 Ok(value)
331 } else {
332 self.bytes.err(ParseError::ExpectedArrayEnd)
333 }
334 } else {
335 self.bytes.err(ParseError::ExpectedArray)
336 }
337 }
338
deserialize_tuple_struct<V>( self, name: &'static str, len: usize, visitor: V ) -> Result<V::Value> where V: Visitor<'de>339 fn deserialize_tuple_struct<V>(
340 self,
341 name: &'static str,
342 len: usize,
343 visitor: V
344 ) -> Result<V::Value>
345 where V: Visitor<'de>
346 {
347 self.bytes.consume(name);
348 self.deserialize_tuple(len, visitor)
349 }
350
deserialize_map<V>(mut self, visitor: V) -> Result<V::Value> where V: Visitor<'de>351 fn deserialize_map<V>(mut self, visitor: V) -> Result<V::Value>
352 where V: Visitor<'de>
353 {
354 if self.bytes.consume("{") {
355 let value = visitor.visit_map(CommaSeparated::new(b'}', &mut self))?;
356 self.bytes.comma();
357
358 if self.bytes.consume("}") {
359 Ok(value)
360 } else {
361 self.bytes.err(ParseError::ExpectedMapEnd)
362 }
363 } else {
364 self.bytes.err(ParseError::ExpectedMap)
365 }
366 }
367
deserialize_struct<V>( mut self, name: &'static str, _fields: &'static [&'static str], visitor: V ) -> Result<V::Value> where V: Visitor<'de>368 fn deserialize_struct<V>(
369 mut self,
370 name: &'static str,
371 _fields: &'static [&'static str],
372 visitor: V
373 ) -> Result<V::Value>
374 where V: Visitor<'de>
375 {
376 self.bytes.consume(name);
377
378 self.bytes.skip_ws();
379
380 if self.bytes.consume("(") {
381 let value = visitor.visit_map(CommaSeparated::new(b')', &mut self))?;
382 self.bytes.comma();
383
384 if self.bytes.consume(")") {
385 Ok(value)
386 } else {
387 self.bytes.err(ParseError::ExpectedStructEnd)
388 }
389 } else {
390 self.bytes.err(ParseError::ExpectedStruct)
391 }
392 }
393
deserialize_enum<V>( self, _name: &'static str, _variants: &'static [&'static str], visitor: V ) -> Result<V::Value> where V: Visitor<'de>394 fn deserialize_enum<V>(
395 self,
396 _name: &'static str,
397 _variants: &'static [&'static str],
398 visitor: V
399 ) -> Result<V::Value>
400 where V: Visitor<'de>
401 {
402 visitor.visit_enum(Enum::new(self))
403 }
404
deserialize_identifier<V>( self, visitor: V ) -> Result<V::Value> where V: Visitor<'de>405 fn deserialize_identifier<V>(
406 self,
407 visitor: V
408 ) -> Result<V::Value>
409 where V: Visitor<'de>
410 {
411 visitor.visit_bytes(self.bytes.identifier()?)
412 }
413
deserialize_ignored_any<V>( self, visitor: V ) -> Result<V::Value> where V: Visitor<'de>414 fn deserialize_ignored_any<V>(
415 self,
416 visitor: V
417 ) -> Result<V::Value>
418 where V: Visitor<'de>
419 {
420 self.deserialize_any(visitor)
421 }
422 }
423
424 struct CommaSeparated<'a, 'de: 'a> {
425 de: &'a mut Deserializer<'de>,
426 terminator: u8,
427 had_comma: bool,
428 }
429
430 impl<'a, 'de> CommaSeparated<'a, 'de> {
new(terminator: u8, de: &'a mut Deserializer<'de>) -> Self431 fn new(terminator: u8, de: &'a mut Deserializer<'de>) -> Self {
432 CommaSeparated { de, terminator, had_comma: true }
433 }
434
err<T>(&self, kind: ParseError) -> Result<T>435 fn err<T>(&self, kind: ParseError) -> Result<T> {
436 self.de.bytes.err(kind)
437 }
438
has_element(&mut self) -> Result<bool>439 fn has_element(&mut self) -> Result<bool> {
440 self.de.bytes.skip_ws();
441
442 Ok(self.had_comma &&
443 self.de.bytes.peek_or_eof()? != self.terminator)
444 }
445 }
446
447 impl<'de, 'a> de::SeqAccess<'de> for CommaSeparated<'a, 'de> {
448 type Error = Error;
449
next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>> where T: DeserializeSeed<'de>450 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
451 where T: DeserializeSeed<'de>
452 {
453 if self.has_element()? {
454 let res = seed.deserialize(&mut *self.de)?;
455
456 self.had_comma = self.de.bytes.comma();
457
458 Ok(Some(res))
459 } else {
460 Ok(None)
461 }
462 }
463 }
464
465 impl<'de, 'a> de::MapAccess<'de> for CommaSeparated<'a, 'de> {
466 type Error = Error;
467
next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>> where K: DeserializeSeed<'de>468 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
469 where K: DeserializeSeed<'de>
470 {
471 if self.has_element()? {
472 if self.terminator == b')' {
473 seed.deserialize(&mut IdDeserializer::new(&mut *self.de)).map(Some)
474 } else {
475 seed.deserialize(&mut *self.de).map(Some)
476 }
477 } else {
478 Ok(None)
479 }
480 }
481
next_value_seed<V>(&mut self, seed: V) -> Result<V::Value> where V: DeserializeSeed<'de>482 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
483 where V: DeserializeSeed<'de>
484 {
485 self.de.bytes.skip_ws();
486
487 if self.de.bytes.consume(":") {
488 self.de.bytes.skip_ws();
489
490 let res = seed.deserialize(&mut *self.de)?;
491
492 self.had_comma = self.de.bytes.comma();
493
494 Ok(res)
495 } else {
496 self.err(ParseError::ExpectedMapColon)
497 }
498 }
499 }
500
501 struct Enum<'a, 'de: 'a> {
502 de: &'a mut Deserializer<'de>,
503 }
504
505 impl<'a, 'de> Enum<'a, 'de> {
new(de: &'a mut Deserializer<'de>) -> Self506 fn new(de: &'a mut Deserializer<'de>) -> Self {
507 Enum { de }
508 }
509 }
510
511 impl<'de, 'a> de::EnumAccess<'de> for Enum<'a, 'de> {
512 type Error = Error;
513 type Variant = Self;
514
variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)> where V: DeserializeSeed<'de>515 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
516 where V: DeserializeSeed<'de>
517 {
518 let value = seed.deserialize(&mut *self.de)?;
519
520 Ok((value, self))
521 }
522 }
523
524 impl<'de, 'a> de::VariantAccess<'de> for Enum<'a, 'de> {
525 type Error = Error;
526
unit_variant(self) -> Result<()>527 fn unit_variant(self) -> Result<()> {
528 Ok(())
529 }
530
newtype_variant_seed<T>(self, seed: T) -> Result<T::Value> where T: DeserializeSeed<'de>531 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
532 where T: DeserializeSeed<'de>
533 {
534 self.de.bytes.skip_ws();
535
536 if self.de.bytes.consume("(") {
537 let val = seed.deserialize(&mut *self.de)?;
538
539 self.de.bytes.comma();
540
541 if self.de.bytes.consume(")") {
542 Ok(val)
543 } else {
544 self.de.bytes.err(ParseError::ExpectedStructEnd)
545 }
546 } else {
547 self.de.bytes.err(ParseError::ExpectedStruct)
548 }
549 }
550
tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value> where V: Visitor<'de>551 fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value>
552 where V: Visitor<'de>
553 {
554 self.de.bytes.skip_ws();
555
556 self.de.deserialize_tuple(len, visitor)
557 }
558
struct_variant<V>( self, fields: &'static [&'static str], visitor: V, ) -> Result<V::Value> where V: Visitor<'de>559 fn struct_variant<V>(
560 self,
561 fields: &'static [&'static str],
562 visitor: V,
563 ) -> Result<V::Value>
564 where V: Visitor<'de>
565 {
566 self.de.bytes.skip_ws();
567
568 self.de.deserialize_struct("", fields, visitor)
569 }
570 }
571