1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 // Rust JSON serialization library
12 // Copyright (c) 2011 Google Inc.
14 #![forbid(non_camel_case_types)]
15 #![allow(missing_doc)]
18 JSON parsing and serialization
22 JSON (JavaScript Object Notation) is a way to write data in Javascript.
23 Like XML, it allows to encode structured data in a text format that can be easily read by humans.
24 Its simple syntax and native compatibility with JavaScript have made it a widely used format.
26 Data types that can be encoded are JavaScript types (see the `Json` enum for more details):
28 * `Boolean`: equivalent to rust's `bool`
29 * `Number`: equivalent to rust's `f64`
30 * `String`: equivalent to rust's `String`
31 * `List`: equivalent to rust's `Vec<T>`, but also allowing objects of different types in the same
33 * `Object`: equivalent to rust's `Treemap<String, json::Json>`
36 An object is a series of string keys mapping to values, in `"key": value` format.
37 Arrays are enclosed in square brackets ([ ... ]) and objects in curly brackets ({ ... }).
38 A simple JSON document encoding a person, his/her age, address and phone numbers could look like:
46 "Street": "Downing Street 10",
48 "Country": "Great Britain"
57 # Rust Type-based Encoding and Decoding
59 Rust provides a mechanism for low boilerplate encoding & decoding of values to and from JSON via
60 the serialization API.
61 To be able to encode a piece of data, it must implement the `serialize::Encodable` trait.
62 To be able to decode a piece of data, it must implement the `serialize::Decodable` trait.
63 The Rust compiler provides an annotation to automatically generate the code for these traits:
64 `#[deriving(Decodable, Encodable)]`
66 The JSON API provides an enum `json::Json` and a trait `ToJson` to encode objects.
67 The `ToJson` trait provides a `to_json` method to convert an object into a `json::Json` value.
68 A `json::Json` value can be encoded as a string or buffer using the functions described above.
69 You can also use the `json::Encoder` object, which implements the `Encoder` trait.
71 When using `ToJson` the `Encodable` trait implementation is not mandatory.
75 ## Using Autoserialization
77 Create a struct called `TestStruct` and serialize and deserialize it to and from JSON using the
78 serialization API, using the derived serialization code.
81 extern crate serialize;
84 // Automatically generate `Decodable` and `Encodable` trait implementations
85 #[deriving(Decodable, Encodable)]
86 pub struct TestStruct {
93 let object = TestStruct {
95 data_str: "toto".to_string(),
96 data_vector: vec![2,3,4,5],
99 // Serialize using `json::encode`
100 let encoded = json::encode(&object);
102 // Deserialize using `json::decode`
103 let decoded: TestStruct = json::decode(encoded.as_slice()).unwrap();
107 ## Using the `ToJson` trait
109 The examples above use the `ToJson` trait to generate the JSON string, which is required
112 ### Simple example of `ToJson` usage
115 extern crate serialize;
116 use serialize::json::ToJson;
119 // A custom data structure
125 // JSON value representation
126 impl ToJson for ComplexNum {
127 fn to_json(&self) -> json::Json {
128 json::String(format!("{}+{}i", self.a, self.b))
132 // Only generate `Encodable` trait implementation
133 #[deriving(Encodable)]
134 pub struct ComplexNumRecord {
141 let num = ComplexNum { a: 0.0001, b: 12.539 };
142 let data: String = json::encode(&ComplexNumRecord{
144 dsc: "test".to_string(),
147 println!("data: {}", data);
148 // data: {"uid":1,"dsc":"test","val":"0.0001+12.539j"};
152 ### Verbose example of `ToJson` usage
155 extern crate serialize;
156 use std::collections::TreeMap;
157 use serialize::json::ToJson;
160 // Only generate `Decodable` trait implementation
161 #[deriving(Decodable)]
162 pub struct TestStruct {
165 data_vector: Vec<u8>,
168 // Specify encoding method manually
169 impl ToJson for TestStruct {
170 fn to_json(&self) -> json::Json {
171 let mut d = TreeMap::new();
172 // All standard types implement `to_json()`, so use it
173 d.insert("data_int".to_string(), self.data_int.to_json());
174 d.insert("data_str".to_string(), self.data_str.to_json());
175 d.insert("data_vector".to_string(), self.data_vector.to_json());
181 // Serialize using `ToJson`
182 let input_data = TestStruct {
184 data_str: "toto".to_string(),
185 data_vector: vec![2,3,4,5],
187 let json_obj: json::Json = input_data.to_json();
188 let json_str: String = json_obj.to_string();
190 // Deserialize like before
191 let decoded: TestStruct = json::decode(json_str.as_slice()).unwrap();
198 use std::collections::{HashMap, TreeMap};
199 use std::{char, f64, fmt, io, num, str};
200 use std::io::MemWriter;
201 use std::mem::{swap, transmute};
202 use std::num::{FPNaN, FPInfinite};
203 use std::str::ScalarValue;
209 /// Represents a json value
210 #[deriving(Clone, PartialEq, PartialOrd)]
215 String(string::String),
222 pub type JsonList = Vec<Json>;
223 pub type JsonObject = TreeMap<string::String, Json>;
225 /// The errors that can arise while parsing a JSON stream.
226 #[deriving(Clone, PartialEq)]
230 EOFWhileParsingObject,
232 EOFWhileParsingValue,
233 EOFWhileParsingString,
239 InvalidUnicodeCodePoint,
240 LoneLeadingSurrogateInHexEscape,
241 UnexpectedEndOfHexEscape,
247 #[deriving(Clone, PartialEq, Show)]
248 pub enum ParserError {
250 SyntaxError(ErrorCode, uint, uint),
251 IoError(io::IoErrorKind, &'static str),
254 // Builder and Parser have the same errors.
255 pub type BuilderError = ParserError;
257 #[deriving(Clone, PartialEq, Show)]
258 pub enum DecoderError {
259 ParseError(ParserError),
260 ExpectedError(string::String, string::String),
261 MissingFieldError(string::String),
262 UnknownVariantError(string::String),
263 ApplicationError(string::String)
266 /// Returns a readable error string for a given error code.
267 pub fn error_str(error: ErrorCode) -> &'static str {
269 InvalidSyntax => "invalid syntax",
270 InvalidNumber => "invalid number",
271 EOFWhileParsingObject => "EOF While parsing object",
272 EOFWhileParsingList => "EOF While parsing list",
273 EOFWhileParsingValue => "EOF While parsing value",
274 EOFWhileParsingString => "EOF While parsing string",
275 KeyMustBeAString => "key must be a string",
276 ExpectedColon => "expected `:`",
277 TrailingCharacters => "trailing characters",
278 TrailingComma => "trailing comma",
279 InvalidEscape => "invalid escape",
280 UnrecognizedHex => "invalid \\u escape (unrecognized hex)",
281 NotFourDigit => "invalid \\u escape (not four digits)",
282 NotUtf8 => "contents not utf-8",
283 InvalidUnicodeCodePoint => "invalid Unicode code point",
284 LoneLeadingSurrogateInHexEscape => "lone leading surrogate in hex escape",
285 UnexpectedEndOfHexEscape => "unexpected end of hex escape",
289 /// Shortcut function to decode a JSON `&str` into an object
290 pub fn decode<T: ::Decodable<Decoder, DecoderError>>(s: &str) -> DecodeResult<T> {
291 let json = match from_str(s) {
293 Err(e) => return Err(ParseError(e))
296 let mut decoder = Decoder::new(json);
297 ::Decodable::decode(&mut decoder)
300 /// Shortcut function to encode a `T` into a JSON `String`
301 pub fn encode<'a, T: Encodable<Encoder<'a>, io::IoError>>(object: &T) -> string::String {
302 let buff = Encoder::buffer_encode(object);
303 string::String::from_utf8(buff).unwrap()
306 impl fmt::Show for ErrorCode {
307 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
308 error_str(*self).fmt(f)
312 fn io_error_to_error(io: io::IoError) -> ParserError {
313 IoError(io.kind, io.desc)
316 pub type EncodeResult = io::IoResult<()>;
317 pub type DecodeResult<T> = Result<T, DecoderError>;
319 pub fn escape_bytes(wr: &mut io::Writer, bytes: &[u8]) -> Result<(), io::IoError> {
320 try!(wr.write_str("\""));
324 for (i, byte) in bytes.iter().enumerate() {
325 let escaped = match *byte {
337 try!(wr.write(bytes.slice(start, i)));
340 try!(wr.write_str(escaped));
345 if start != bytes.len() {
346 try!(wr.write(bytes.slice_from(start)));
352 fn escape_str(writer: &mut io::Writer, v: &str) -> Result<(), io::IoError> {
353 escape_bytes(writer, v.as_bytes())
356 fn escape_char(writer: &mut io::Writer, v: char) -> Result<(), io::IoError> {
357 let mut buf = [0, .. 4];
359 escape_bytes(writer, buf)
362 fn spaces(wr: &mut io::Writer, mut n: uint) -> Result<(), io::IoError> {
363 static len: uint = 16;
364 static buf: [u8, ..len] = [b' ', ..len];
372 wr.write(buf.slice_to(n))
378 fn fmt_number_or_null(v: f64) -> string::String {
380 FPNaN | FPInfinite => string::String::from_str("null"),
381 _ => f64::to_str_digits(v, 6u)
385 /// A structure for implementing serialization to JSON.
386 pub struct Encoder<'a> {
387 writer: &'a mut io::Writer+'a,
390 impl<'a> Encoder<'a> {
391 /// Creates a new JSON encoder whose output will be written to the writer
393 pub fn new(writer: &'a mut io::Writer) -> Encoder<'a> {
394 Encoder { writer: writer }
397 /// Encode the specified struct into a json [u8]
398 pub fn buffer_encode<T:Encodable<Encoder<'a>, io::IoError>>(object: &T) -> Vec<u8> {
399 //Serialize the object in a string using a writer
400 let mut m = MemWriter::new();
401 // FIXME(14302) remove the transmute and unsafe block.
403 let mut encoder = Encoder::new(&mut m as &mut io::Writer);
404 // MemWriter never Errs
405 let _ = object.encode(transmute(&mut encoder));
410 /// Encode the specified struct into a json str
412 /// Note: this function is deprecated. Consider using `json::encode` instead.
413 #[deprecated = "Replaced by `json::encode`"]
414 pub fn str_encode<T: Encodable<Encoder<'a>, io::IoError>>(object: &T) -> string::String {
419 impl<'a> ::Encoder<io::IoError> for Encoder<'a> {
420 fn emit_nil(&mut self) -> EncodeResult { write!(self.writer, "null") }
422 fn emit_uint(&mut self, v: uint) -> EncodeResult { self.emit_f64(v as f64) }
423 fn emit_u64(&mut self, v: u64) -> EncodeResult { self.emit_f64(v as f64) }
424 fn emit_u32(&mut self, v: u32) -> EncodeResult { self.emit_f64(v as f64) }
425 fn emit_u16(&mut self, v: u16) -> EncodeResult { self.emit_f64(v as f64) }
426 fn emit_u8(&mut self, v: u8) -> EncodeResult { self.emit_f64(v as f64) }
428 fn emit_int(&mut self, v: int) -> EncodeResult { self.emit_f64(v as f64) }
429 fn emit_i64(&mut self, v: i64) -> EncodeResult { self.emit_f64(v as f64) }
430 fn emit_i32(&mut self, v: i32) -> EncodeResult { self.emit_f64(v as f64) }
431 fn emit_i16(&mut self, v: i16) -> EncodeResult { self.emit_f64(v as f64) }
432 fn emit_i8(&mut self, v: i8) -> EncodeResult { self.emit_f64(v as f64) }
434 fn emit_bool(&mut self, v: bool) -> EncodeResult {
436 write!(self.writer, "true")
438 write!(self.writer, "false")
442 fn emit_f64(&mut self, v: f64) -> EncodeResult {
443 write!(self.writer, "{}", fmt_number_or_null(v))
445 fn emit_f32(&mut self, v: f32) -> EncodeResult { self.emit_f64(v as f64) }
447 fn emit_char(&mut self, v: char) -> EncodeResult {
448 escape_char(self.writer, v)
450 fn emit_str(&mut self, v: &str) -> EncodeResult {
451 escape_str(self.writer, v)
454 fn emit_enum(&mut self, _name: &str, f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
458 fn emit_enum_variant(&mut self,
462 f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
463 // enums are encoded as strings or objects
465 // Kangaroo(34,"William") => {"variant": "Kangaroo", "fields": [34,"William"]}
467 escape_str(self.writer, name)
469 try!(write!(self.writer, "{{\"variant\":"));
470 try!(escape_str(self.writer, name));
471 try!(write!(self.writer, ",\"fields\":["));
473 write!(self.writer, "]}}")
477 fn emit_enum_variant_arg(&mut self,
479 f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
481 try!(write!(self.writer, ","));
486 fn emit_enum_struct_variant(&mut self,
490 f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
491 self.emit_enum_variant(name, id, cnt, f)
494 fn emit_enum_struct_variant_field(&mut self,
497 f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
498 self.emit_enum_variant_arg(idx, f)
501 fn emit_struct(&mut self,
504 f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
505 try!(write!(self.writer, "{{"));
507 write!(self.writer, "}}")
510 fn emit_struct_field(&mut self,
513 f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
514 if idx != 0 { try!(write!(self.writer, ",")); }
515 try!(escape_str(self.writer, name));
516 try!(write!(self.writer, ":"));
520 fn emit_tuple(&mut self, len: uint, f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
521 self.emit_seq(len, f)
523 fn emit_tuple_arg(&mut self,
525 f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
526 self.emit_seq_elt(idx, f)
529 fn emit_tuple_struct(&mut self,
532 f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
533 self.emit_seq(len, f)
535 fn emit_tuple_struct_arg(&mut self,
537 f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
538 self.emit_seq_elt(idx, f)
541 fn emit_option(&mut self, f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
544 fn emit_option_none(&mut self) -> EncodeResult { self.emit_nil() }
545 fn emit_option_some(&mut self, f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
549 fn emit_seq(&mut self, _len: uint, f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
550 try!(write!(self.writer, "["));
552 write!(self.writer, "]")
555 fn emit_seq_elt(&mut self, idx: uint, f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
557 try!(write!(self.writer, ","));
562 fn emit_map(&mut self, _len: uint, f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
563 try!(write!(self.writer, "{{"));
565 write!(self.writer, "}}")
568 fn emit_map_elt_key(&mut self,
570 f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
571 if idx != 0 { try!(write!(self.writer, ",")) }
572 // ref #12967, make sure to wrap a key in double quotes,
573 // in the event that its of a type that omits them (eg numbers)
574 let mut buf = MemWriter::new();
575 // FIXME(14302) remove the transmute and unsafe block.
577 let mut check_encoder = Encoder::new(&mut buf);
578 try!(f(transmute(&mut check_encoder)));
580 let out = str::from_utf8(buf.get_ref()).unwrap();
581 let needs_wrapping = out.char_at(0) != '"' && out.char_at_reverse(out.len()) != '"';
582 if needs_wrapping { try!(write!(self.writer, "\"")); }
584 if needs_wrapping { try!(write!(self.writer, "\"")); }
588 fn emit_map_elt_val(&mut self,
590 f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
591 try!(write!(self.writer, ":"));
596 /// Another encoder for JSON, but prints out human-readable JSON instead of
598 pub struct PrettyEncoder<'a> {
599 writer: &'a mut io::Writer+'a,
604 impl<'a> PrettyEncoder<'a> {
605 /// Creates a new encoder whose output will be written to the specified writer
606 pub fn new<'a>(writer: &'a mut io::Writer) -> PrettyEncoder<'a> {
607 PrettyEncoder { writer: writer, curr_indent: 0, indent: 2, }
610 /// Set the number of spaces to indent for each level.
611 /// This is safe to set during encoding.
612 pub fn set_indent<'a>(&mut self, indent: uint) {
613 // self.indent very well could be 0 so we need to use checked division.
614 let level = self.curr_indent.checked_div(&self.indent).unwrap_or(0);
615 self.indent = indent;
616 self.curr_indent = level * self.indent;
620 impl<'a> ::Encoder<io::IoError> for PrettyEncoder<'a> {
621 fn emit_nil(&mut self) -> EncodeResult { write!(self.writer, "null") }
623 fn emit_uint(&mut self, v: uint) -> EncodeResult { self.emit_f64(v as f64) }
624 fn emit_u64(&mut self, v: u64) -> EncodeResult { self.emit_f64(v as f64) }
625 fn emit_u32(&mut self, v: u32) -> EncodeResult { self.emit_f64(v as f64) }
626 fn emit_u16(&mut self, v: u16) -> EncodeResult { self.emit_f64(v as f64) }
627 fn emit_u8(&mut self, v: u8) -> EncodeResult { self.emit_f64(v as f64) }
629 fn emit_int(&mut self, v: int) -> EncodeResult { self.emit_f64(v as f64) }
630 fn emit_i64(&mut self, v: i64) -> EncodeResult { self.emit_f64(v as f64) }
631 fn emit_i32(&mut self, v: i32) -> EncodeResult { self.emit_f64(v as f64) }
632 fn emit_i16(&mut self, v: i16) -> EncodeResult { self.emit_f64(v as f64) }
633 fn emit_i8(&mut self, v: i8) -> EncodeResult { self.emit_f64(v as f64) }
635 fn emit_bool(&mut self, v: bool) -> EncodeResult {
637 write!(self.writer, "true")
639 write!(self.writer, "false")
643 fn emit_f64(&mut self, v: f64) -> EncodeResult {
644 write!(self.writer, "{}", fmt_number_or_null(v))
646 fn emit_f32(&mut self, v: f32) -> EncodeResult {
647 self.emit_f64(v as f64)
650 fn emit_char(&mut self, v: char) -> EncodeResult {
651 escape_char(self.writer, v)
653 fn emit_str(&mut self, v: &str) -> EncodeResult {
654 escape_str(self.writer, v)
657 fn emit_enum(&mut self,
659 f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
663 fn emit_enum_variant(&mut self,
667 f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
669 escape_str(self.writer, name)
671 self.curr_indent += self.indent;
672 try!(write!(self.writer, "[\n"));
673 try!(spaces(self.writer, self.curr_indent));
674 try!(escape_str(self.writer, name));
675 try!(write!(self.writer, ",\n"));
677 self.curr_indent -= self.indent;
678 try!(write!(self.writer, "\n"));
679 try!(spaces(self.writer, self.curr_indent));
680 write!(self.writer, "]")
684 fn emit_enum_variant_arg(&mut self,
686 f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
688 try!(write!(self.writer, ",\n"));
690 try!(spaces(self.writer, self.curr_indent));
694 fn emit_enum_struct_variant(&mut self,
698 f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
699 self.emit_enum_variant(name, id, cnt, f)
702 fn emit_enum_struct_variant_field(&mut self,
705 f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
706 self.emit_enum_variant_arg(idx, f)
710 fn emit_struct(&mut self,
713 f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
715 write!(self.writer, "{{}}")
717 try!(write!(self.writer, "{{"));
718 self.curr_indent += self.indent;
720 self.curr_indent -= self.indent;
721 try!(write!(self.writer, "\n"));
722 try!(spaces(self.writer, self.curr_indent));
723 write!(self.writer, "}}")
727 fn emit_struct_field(&mut self,
730 f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
732 try!(write!(self.writer, "\n"));
734 try!(write!(self.writer, ",\n"));
736 try!(spaces(self.writer, self.curr_indent));
737 try!(escape_str(self.writer, name));
738 try!(write!(self.writer, ": "));
742 fn emit_tuple(&mut self,
744 f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
745 self.emit_seq(len, f)
747 fn emit_tuple_arg(&mut self,
749 f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
750 self.emit_seq_elt(idx, f)
753 fn emit_tuple_struct(&mut self,
756 f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
757 self.emit_seq(len, f)
759 fn emit_tuple_struct_arg(&mut self,
761 f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
762 self.emit_seq_elt(idx, f)
765 fn emit_option(&mut self, f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
768 fn emit_option_none(&mut self) -> EncodeResult { self.emit_nil() }
769 fn emit_option_some(&mut self, f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
773 fn emit_seq(&mut self,
775 f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
777 write!(self.writer, "[]")
779 try!(write!(self.writer, "["));
780 self.curr_indent += self.indent;
782 self.curr_indent -= self.indent;
783 try!(write!(self.writer, "\n"));
784 try!(spaces(self.writer, self.curr_indent));
785 write!(self.writer, "]")
789 fn emit_seq_elt(&mut self,
791 f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
793 try!(write!(self.writer, "\n"));
795 try!(write!(self.writer, ",\n"));
797 try!(spaces(self.writer, self.curr_indent));
801 fn emit_map(&mut self,
803 f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
805 write!(self.writer, "{{}}")
807 try!(write!(self.writer, "{{"));
808 self.curr_indent += self.indent;
810 self.curr_indent -= self.indent;
811 try!(write!(self.writer, "\n"));
812 try!(spaces(self.writer, self.curr_indent));
813 write!(self.writer, "}}")
817 fn emit_map_elt_key(&mut self,
819 f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
821 try!(write!(self.writer, "\n"));
823 try!(write!(self.writer, ",\n"));
825 try!(spaces(self.writer, self.curr_indent));
826 // ref #12967, make sure to wrap a key in double quotes,
827 // in the event that its of a type that omits them (eg numbers)
828 let mut buf = MemWriter::new();
829 // FIXME(14302) remove the transmute and unsafe block.
831 let mut check_encoder = PrettyEncoder::new(&mut buf);
832 try!(f(transmute(&mut check_encoder)));
834 let out = str::from_utf8(buf.get_ref()).unwrap();
835 let needs_wrapping = out.char_at(0) != '"' && out.char_at_reverse(out.len()) != '"';
836 if needs_wrapping { try!(write!(self.writer, "\"")); }
838 if needs_wrapping { try!(write!(self.writer, "\"")); }
842 fn emit_map_elt_val(&mut self,
844 f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
845 try!(write!(self.writer, ": "));
850 impl<E: ::Encoder<S>, S> Encodable<E, S> for Json {
851 fn encode(&self, e: &mut E) -> Result<(), S> {
853 I64(v) => v.encode(e),
854 U64(v) => v.encode(e),
855 F64(v) => v.encode(e),
856 String(ref v) => v.encode(e),
857 Boolean(v) => v.encode(e),
858 List(ref v) => v.encode(e),
859 Object(ref v) => v.encode(e),
860 Null => e.emit_nil(),
866 /// Encodes a json value into an io::writer. Uses a single line.
867 pub fn to_writer(&self, writer: &mut io::Writer) -> EncodeResult {
868 let mut encoder = Encoder::new(writer);
869 self.encode(&mut encoder)
872 /// Encodes a json value into an io::writer.
873 /// Pretty-prints in a more readable format.
874 pub fn to_pretty_writer(&self, writer: &mut io::Writer) -> EncodeResult {
875 let mut encoder = PrettyEncoder::new(writer);
876 self.encode(&mut encoder)
879 /// Encodes a json value into a string
880 pub fn to_pretty_str(&self) -> string::String {
881 let mut s = MemWriter::new();
882 self.to_pretty_writer(&mut s as &mut io::Writer).unwrap();
883 string::String::from_utf8(s.unwrap()).unwrap()
886 /// If the Json value is an Object, returns the value associated with the provided key.
887 /// Otherwise, returns None.
888 pub fn find<'a>(&'a self, key: &string::String) -> Option<&'a Json>{
890 &Object(ref map) => map.find(key),
895 /// Attempts to get a nested Json Object for each key in `keys`.
896 /// If any key is found not to exist, find_path will return None.
897 /// Otherwise, it will return the Json value associated with the final key.
898 pub fn find_path<'a>(&'a self, keys: &[&string::String]) -> Option<&'a Json>{
899 let mut target = self;
900 for key in keys.iter() {
901 match target.find(*key) {
902 Some(t) => { target = t; },
909 /// If the Json value is an Object, performs a depth-first search until
910 /// a value associated with the provided key is found. If no value is found
911 /// or the Json value is not an Object, returns None.
912 pub fn search<'a>(&'a self, key: &string::String) -> Option<&'a Json> {
914 &Object(ref map) => {
915 match map.find(key) {
916 Some(json_value) => Some(json_value),
918 let mut value : Option<&'a Json> = None;
919 for (_, v) in map.iter() {
920 value = v.search(key);
933 /// Returns true if the Json value is an Object. Returns false otherwise.
934 pub fn is_object<'a>(&'a self) -> bool {
935 self.as_object().is_some()
938 /// If the Json value is an Object, returns the associated TreeMap.
939 /// Returns None otherwise.
940 pub fn as_object<'a>(&'a self) -> Option<&'a JsonObject> {
942 &Object(ref map) => Some(map),
947 /// Returns true if the Json value is a List. Returns false otherwise.
948 pub fn is_list<'a>(&'a self) -> bool {
949 self.as_list().is_some()
952 /// If the Json value is a List, returns the associated vector.
953 /// Returns None otherwise.
954 pub fn as_list<'a>(&'a self) -> Option<&'a JsonList> {
956 &List(ref list) => Some(&*list),
961 /// Returns true if the Json value is a String. Returns false otherwise.
962 pub fn is_string<'a>(&'a self) -> bool {
963 self.as_string().is_some()
966 /// If the Json value is a String, returns the associated str.
967 /// Returns None otherwise.
968 pub fn as_string<'a>(&'a self) -> Option<&'a str> {
970 String(ref s) => Some(s.as_slice()),
975 /// Returns true if the Json value is a Number. Returns false otherwise.
976 pub fn is_number(&self) -> bool {
978 I64(_) | U64(_) | F64(_) => true,
983 /// Returns true if the Json value is a i64. Returns false otherwise.
984 pub fn is_i64(&self) -> bool {
991 /// Returns true if the Json value is a u64. Returns false otherwise.
992 pub fn is_u64(&self) -> bool {
999 /// Returns true if the Json value is a f64. Returns false otherwise.
1000 pub fn is_f64(&self) -> bool {
1007 /// If the Json value is a number, return or cast it to a i64.
1008 /// Returns None otherwise.
1009 pub fn as_i64(&self) -> Option<i64> {
1012 U64(n) => num::cast(n),
1017 /// If the Json value is a number, return or cast it to a u64.
1018 /// Returns None otherwise.
1019 pub fn as_u64(&self) -> Option<u64> {
1021 I64(n) => num::cast(n),
1027 /// If the Json value is a number, return or cast it to a f64.
1028 /// Returns None otherwise.
1029 pub fn as_f64(&self) -> Option<f64> {
1031 I64(n) => num::cast(n),
1032 U64(n) => num::cast(n),
1038 /// Returns true if the Json value is a Boolean. Returns false otherwise.
1039 pub fn is_boolean(&self) -> bool {
1040 self.as_boolean().is_some()
1043 /// If the Json value is a Boolean, returns the associated bool.
1044 /// Returns None otherwise.
1045 pub fn as_boolean(&self) -> Option<bool> {
1047 &Boolean(b) => Some(b),
1052 /// Returns true if the Json value is a Null. Returns false otherwise.
1053 pub fn is_null(&self) -> bool {
1054 self.as_null().is_some()
1057 /// If the Json value is a Null, returns ().
1058 /// Returns None otherwise.
1059 pub fn as_null(&self) -> Option<()> {
1067 /// The output of the streaming parser.
1068 #[deriving(PartialEq, Clone, Show)]
1069 pub enum JsonEvent {
1078 StringValue(string::String),
1083 #[deriving(PartialEq, Show)]
1085 // Parse a value in a list, true means first element.
1087 // Parse ',' or ']' after an element in a list.
1089 // Parse a key:value in an object, true means first element.
1091 // Parse ',' or ']' after an element in an object.
1095 // Expecting the stream to end.
1097 // Parsing can't continue.
1101 /// A Stack represents the current position of the parser in the logical
1102 /// structure of the JSON stream.
1103 /// For example foo.bar[3].x
1105 stack: Vec<InternalStackElement>,
1106 str_buffer: Vec<u8>,
1109 /// StackElements compose a Stack.
1110 /// For example, Key("foo"), Key("bar"), Index(3) and Key("x") are the
1111 /// StackElements compositing the stack that represents foo.bar[3].x
1112 #[deriving(PartialEq, Clone, Show)]
1113 pub enum StackElement<'l> {
1118 // Internally, Key elements are stored as indices in a buffer to avoid
1119 // allocating a string for every member of an object.
1120 #[deriving(PartialEq, Clone, Show)]
1121 enum InternalStackElement {
1123 InternalKey(u16, u16), // start, size
1127 pub fn new() -> Stack {
1128 Stack { stack: Vec::new(), str_buffer: Vec::new() }
1131 /// Returns The number of elements in the Stack.
1132 pub fn len(&self) -> uint { self.stack.len() }
1134 /// Returns true if the stack is empty.
1135 pub fn is_empty(&self) -> bool { self.stack.is_empty() }
1137 /// Provides access to the StackElement at a given index.
1138 /// lower indices are at the bottom of the stack while higher indices are
1140 pub fn get<'l>(&'l self, idx: uint) -> StackElement<'l> {
1141 match self.stack[idx] {
1142 InternalIndex(i) => { Index(i) }
1143 InternalKey(start, size) => {
1145 self.str_buffer.slice(start as uint, start as uint + size as uint)).unwrap())
1150 /// Compares this stack with an array of StackElements.
1151 pub fn is_equal_to(&self, rhs: &[StackElement]) -> bool {
1152 if self.stack.len() != rhs.len() { return false; }
1153 for i in range(0, rhs.len()) {
1154 if self.get(i) != rhs[i] { return false; }
1159 /// Returns true if the bottom-most elements of this stack are the same as
1160 /// the ones passed as parameter.
1161 pub fn starts_with(&self, rhs: &[StackElement]) -> bool {
1162 if self.stack.len() < rhs.len() { return false; }
1163 for i in range(0, rhs.len()) {
1164 if self.get(i) != rhs[i] { return false; }
1169 /// Returns true if the top-most elements of this stack are the same as
1170 /// the ones passed as parameter.
1171 pub fn ends_with(&self, rhs: &[StackElement]) -> bool {
1172 if self.stack.len() < rhs.len() { return false; }
1173 let offset = self.stack.len() - rhs.len();
1174 for i in range(0, rhs.len()) {
1175 if self.get(i + offset) != rhs[i] { return false; }
1180 /// Returns the top-most element (if any).
1181 pub fn top<'l>(&'l self) -> Option<StackElement<'l>> {
1182 return match self.stack.last() {
1184 Some(&InternalIndex(i)) => Some(Index(i)),
1185 Some(&InternalKey(start, size)) => {
1186 Some(Key(str::from_utf8(
1187 self.str_buffer.slice(start as uint, (start+size) as uint)
1193 // Used by Parser to insert Key elements at the top of the stack.
1194 fn push_key(&mut self, key: string::String) {
1195 self.stack.push(InternalKey(self.str_buffer.len() as u16, key.len() as u16));
1196 for c in key.as_bytes().iter() {
1197 self.str_buffer.push(*c);
1201 // Used by Parser to insert Index elements at the top of the stack.
1202 fn push_index(&mut self, index: u32) {
1203 self.stack.push(InternalIndex(index));
1206 // Used by Parser to remove the top-most element of the stack.
1208 assert!(!self.is_empty());
1209 match *self.stack.last().unwrap() {
1210 InternalKey(_, sz) => {
1211 let new_size = self.str_buffer.len() - sz as uint;
1212 self.str_buffer.truncate(new_size);
1214 InternalIndex(_) => {}
1219 // Used by Parser to test whether the top-most element is an index.
1220 fn last_is_index(&self) -> bool {
1221 if self.is_empty() { return false; }
1222 return match *self.stack.last().unwrap() {
1223 InternalIndex(_) => true,
1228 // Used by Parser to increment the index of the top-most element.
1229 fn bump_index(&mut self) {
1230 let len = self.stack.len();
1231 let idx = match *self.stack.last().unwrap() {
1232 InternalIndex(i) => { i + 1 }
1235 *self.stack.get_mut(len - 1) = InternalIndex(idx);
1239 /// A streaming JSON parser implemented as an iterator of JsonEvent, consuming
1240 /// an iterator of char.
1241 pub struct Parser<T> {
1246 // We maintain a stack representing where we are in the logical structure
1247 // of the JSON stream.
1249 // A state machine is kept to make it possible to interrupt and resume parsing.
1253 impl<T: Iterator<char>> Iterator<JsonEvent> for Parser<T> {
1254 fn next(&mut self) -> Option<JsonEvent> {
1255 if self.state == ParseFinished {
1259 if self.state == ParseBeforeFinish {
1260 self.parse_whitespace();
1261 // Make sure there is no trailing characters.
1263 self.state = ParseFinished;
1266 return Some(self.error_event(TrailingCharacters));
1270 return Some(self.parse());
1274 impl<T: Iterator<char>> Parser<T> {
1275 /// Creates the JSON parser.
1276 pub fn new(rdr: T) -> Parser<T> {
1277 let mut p = Parser {
1282 stack: Stack::new(),
1289 /// Provides access to the current position in the logical structure of the
1291 pub fn stack<'l>(&'l self) -> &'l Stack {
1295 fn eof(&self) -> bool { self.ch.is_none() }
1296 fn ch_or_null(&self) -> char { self.ch.unwrap_or('\x00') }
1297 fn bump(&mut self) {
1298 self.ch = self.rdr.next();
1300 if self.ch_is('\n') {
1308 fn next_char(&mut self) -> Option<char> {
1312 fn ch_is(&self, c: char) -> bool {
1316 fn error<T>(&self, reason: ErrorCode) -> Result<T, ParserError> {
1317 Err(SyntaxError(reason, self.line, self.col))
1320 fn parse_whitespace(&mut self) {
1321 while self.ch_is(' ') ||
1324 self.ch_is('\r') { self.bump(); }
1327 fn parse_number(&mut self) -> JsonEvent {
1328 let mut neg = false;
1330 if self.ch_is('-') {
1335 let res = match self.parse_u64() {
1337 Err(e) => { return Error(e); }
1340 if self.ch_is('.') || self.ch_is('e') || self.ch_is('E') {
1341 let mut res = res as f64;
1343 if self.ch_is('.') {
1344 res = match self.parse_decimal(res) {
1346 Err(e) => { return Error(e); }
1350 if self.ch_is('e') || self.ch_is('E') {
1351 res = match self.parse_exponent(res) {
1353 Err(e) => { return Error(e); }
1364 let res = -(res as i64);
1366 // Make sure we didn't underflow.
1368 Error(SyntaxError(InvalidNumber, self.line, self.col))
1378 fn parse_u64(&mut self) -> Result<u64, ParserError> {
1380 let last_accum = 0; // necessary to detect overflow.
1382 match self.ch_or_null() {
1386 // A leading '0' must be the only digit before the decimal point.
1387 match self.ch_or_null() {
1388 '0' .. '9' => return self.error(InvalidNumber),
1394 match self.ch_or_null() {
1397 accum += (c as u64) - ('0' as u64);
1399 // Detect overflow by comparing to the last value.
1400 if accum <= last_accum { return self.error(InvalidNumber); }
1408 _ => return self.error(InvalidNumber),
1414 fn parse_decimal(&mut self, mut res: f64) -> Result<f64, ParserError> {
1417 // Make sure a digit follows the decimal place.
1418 match self.ch_or_null() {
1420 _ => return self.error(InvalidNumber)
1425 match self.ch_or_null() {
1428 res += (((c as int) - ('0' as int)) as f64) * dec;
1438 fn parse_exponent(&mut self, mut res: f64) -> Result<f64, ParserError> {
1442 let mut neg_exp = false;
1444 if self.ch_is('+') {
1446 } else if self.ch_is('-') {
1451 // Make sure a digit follows the exponent place.
1452 match self.ch_or_null() {
1454 _ => return self.error(InvalidNumber)
1457 match self.ch_or_null() {
1460 exp += (c as uint) - ('0' as uint);
1468 let exp = num::pow(10_f64, exp);
1478 fn decode_hex_escape(&mut self) -> Result<u16, ParserError> {
1481 while i < 4 && !self.eof() {
1483 n = match self.ch_or_null() {
1484 c @ '0' .. '9' => n * 16 + ((c as u16) - ('0' as u16)),
1485 'a' | 'A' => n * 16 + 10,
1486 'b' | 'B' => n * 16 + 11,
1487 'c' | 'C' => n * 16 + 12,
1488 'd' | 'D' => n * 16 + 13,
1489 'e' | 'E' => n * 16 + 14,
1490 'f' | 'F' => n * 16 + 15,
1491 _ => return self.error(InvalidEscape)
1497 // Error out if we didn't parse 4 digits.
1499 return self.error(InvalidEscape);
1505 fn parse_str(&mut self) -> Result<string::String, ParserError> {
1506 let mut escape = false;
1507 let mut res = string::String::new();
1512 return self.error(EOFWhileParsingString);
1516 match self.ch_or_null() {
1517 '"' => res.push_char('"'),
1518 '\\' => res.push_char('\\'),
1519 '/' => res.push_char('/'),
1520 'b' => res.push_char('\x08'),
1521 'f' => res.push_char('\x0c'),
1522 'n' => res.push_char('\n'),
1523 'r' => res.push_char('\r'),
1524 't' => res.push_char('\t'),
1525 'u' => match try!(self.decode_hex_escape()) {
1526 0xDC00 .. 0xDFFF => return self.error(LoneLeadingSurrogateInHexEscape),
1528 // Non-BMP characters are encoded as a sequence of
1529 // two hex escapes, representing UTF-16 surrogates.
1530 n1 @ 0xD800 .. 0xDBFF => {
1531 match (self.next_char(), self.next_char()) {
1532 (Some('\\'), Some('u')) => (),
1533 _ => return self.error(UnexpectedEndOfHexEscape),
1536 let buf = [n1, try!(self.decode_hex_escape())];
1537 match str::utf16_items(buf.as_slice()).next() {
1538 Some(ScalarValue(c)) => res.push_char(c),
1539 _ => return self.error(LoneLeadingSurrogateInHexEscape),
1543 n => match char::from_u32(n as u32) {
1544 Some(c) => res.push_char(c),
1545 None => return self.error(InvalidUnicodeCodePoint),
1548 _ => return self.error(InvalidEscape),
1551 } else if self.ch_is('\\') {
1559 Some(c) => res.push_char(c),
1560 None => unreachable!()
1566 // Invoked at each iteration, consumes the stream until it has enough
1567 // information to return a JsonEvent.
1568 // Manages an internal state so that parsing can be interrupted and resumed.
1569 // Also keeps track of the position in the logical structure of the json
1570 // stream int the form of a stack that can be queried by the user using the
1572 fn parse(&mut self) -> JsonEvent {
1574 // The only paths where the loop can spin a new iteration
1575 // are in the cases ParseListComma and ParseObjectComma if ','
1576 // is parsed. In these cases the state is set to (respectively)
1577 // ParseArray(false) and ParseObject(false), which always return,
1578 // so there is no risk of getting stuck in an infinite loop.
1579 // All other paths return before the end of the loop's iteration.
1580 self.parse_whitespace();
1584 return self.parse_start();
1586 ParseArray(first) => {
1587 return self.parse_list(first);
1590 match self.parse_list_comma_or_end() {
1591 Some(evt) => { return evt; }
1595 ParseObject(first) => {
1596 return self.parse_object(first);
1598 ParseObjectComma => {
1600 if self.ch_is(',') {
1601 self.state = ParseObject(false);
1604 return self.parse_object_end();
1608 return self.error_event(InvalidSyntax);
1614 fn parse_start(&mut self) -> JsonEvent {
1615 let val = self.parse_value();
1616 self.state = match val {
1617 Error(_) => { ParseFinished }
1618 ListStart => { ParseArray(true) }
1619 ObjectStart => { ParseObject(true) }
1620 _ => { ParseBeforeFinish }
1625 fn parse_list(&mut self, first: bool) -> JsonEvent {
1626 if self.ch_is(']') {
1628 return self.error_event(InvalidSyntax);
1630 if self.stack.is_empty() {
1631 self.state = ParseBeforeFinish;
1633 self.state = if self.stack.last_is_index() {
1643 self.stack.push_index(0);
1646 let val = self.parse_value();
1648 self.state = match val {
1649 Error(_) => { ParseFinished }
1650 ListStart => { ParseArray(true) }
1651 ObjectStart => { ParseObject(true) }
1652 _ => { ParseListComma }
1657 fn parse_list_comma_or_end(&mut self) -> Option<JsonEvent> {
1658 if self.ch_is(',') {
1659 self.stack.bump_index();
1660 self.state = ParseArray(false);
1663 } else if self.ch_is(']') {
1665 if self.stack.is_empty() {
1666 self.state = ParseBeforeFinish;
1668 self.state = if self.stack.last_is_index() {
1675 return Some(ListEnd);
1676 } else if self.eof() {
1677 return Some(self.error_event(EOFWhileParsingList));
1679 return Some(self.error_event(InvalidSyntax));
1683 fn parse_object(&mut self, first: bool) -> JsonEvent {
1684 if self.ch_is('}') {
1686 if self.stack.is_empty() {
1687 return self.error_event(TrailingComma);
1692 if self.stack.is_empty() {
1693 self.state = ParseBeforeFinish;
1695 self.state = if self.stack.last_is_index() {
1705 return self.error_event(EOFWhileParsingObject);
1707 if !self.ch_is('"') {
1708 return self.error_event(KeyMustBeAString);
1710 let s = match self.parse_str() {
1713 self.state = ParseFinished;
1717 self.parse_whitespace();
1719 return self.error_event(EOFWhileParsingObject);
1720 } else if self.ch_or_null() != ':' {
1721 return self.error_event(ExpectedColon);
1723 self.stack.push_key(s);
1725 self.parse_whitespace();
1727 let val = self.parse_value();
1729 self.state = match val {
1730 Error(_) => { ParseFinished }
1731 ListStart => { ParseArray(true) }
1732 ObjectStart => { ParseObject(true) }
1733 _ => { ParseObjectComma }
1738 fn parse_object_end(&mut self) -> JsonEvent {
1739 if self.ch_is('}') {
1740 if self.stack.is_empty() {
1741 self.state = ParseBeforeFinish;
1743 self.state = if self.stack.last_is_index() {
1751 } else if self.eof() {
1752 self.error_event(EOFWhileParsingObject)
1754 self.error_event(InvalidSyntax)
1758 fn parse_value(&mut self) -> JsonEvent {
1759 if self.eof() { return self.error_event(EOFWhileParsingValue); }
1760 match self.ch_or_null() {
1761 'n' => { self.parse_ident("ull", NullValue) }
1762 't' => { self.parse_ident("rue", BooleanValue(true)) }
1763 'f' => { self.parse_ident("alse", BooleanValue(false)) }
1764 '0' .. '9' | '-' => self.parse_number(),
1765 '"' => match self.parse_str() {
1766 Ok(s) => StringValue(s),
1777 _ => { self.error_event(InvalidSyntax) }
1781 fn parse_ident(&mut self, ident: &str, value: JsonEvent) -> JsonEvent {
1782 if ident.chars().all(|c| Some(c) == self.next_char()) {
1786 Error(SyntaxError(InvalidSyntax, self.line, self.col))
1790 fn error_event(&mut self, reason: ErrorCode) -> JsonEvent {
1791 self.state = ParseFinished;
1792 Error(SyntaxError(reason, self.line, self.col))
1796 /// A Builder consumes a json::Parser to create a generic Json structure.
1797 pub struct Builder<T> {
1799 token: Option<JsonEvent>,
1802 impl<T: Iterator<char>> Builder<T> {
1803 /// Create a JSON Builder.
1804 pub fn new(src: T) -> Builder<T> {
1805 Builder { parser: Parser::new(src), token: None, }
1808 // Decode a Json value from a Parser.
1809 pub fn build(&mut self) -> Result<Json, BuilderError> {
1811 let result = self.build_value();
1815 Some(Error(e)) => { return Err(e); }
1816 ref tok => { fail!("unexpected token {}", tok.clone()); }
1821 fn bump(&mut self) {
1822 self.token = self.parser.next();
1825 fn build_value(&mut self) -> Result<Json, BuilderError> {
1826 return match self.token {
1827 Some(NullValue) => { Ok(Null) }
1828 Some(I64Value(n)) => { Ok(I64(n)) }
1829 Some(U64Value(n)) => { Ok(U64(n)) }
1830 Some(F64Value(n)) => { Ok(F64(n)) }
1831 Some(BooleanValue(b)) => { Ok(Boolean(b)) }
1832 Some(StringValue(ref mut s)) => {
1833 let mut temp = string::String::new();
1837 Some(Error(e)) => { Err(e) }
1838 Some(ListStart) => { self.build_list() }
1839 Some(ObjectStart) => { self.build_object() }
1840 Some(ObjectEnd) => { self.parser.error(InvalidSyntax) }
1841 Some(ListEnd) => { self.parser.error(InvalidSyntax) }
1842 None => { self.parser.error(EOFWhileParsingValue) }
1846 fn build_list(&mut self) -> Result<Json, BuilderError> {
1848 let mut values = Vec::new();
1851 if self.token == Some(ListEnd) {
1852 return Ok(List(values.into_iter().collect()));
1854 match self.build_value() {
1855 Ok(v) => values.push(v),
1856 Err(e) => { return Err(e) }
1862 fn build_object(&mut self) -> Result<Json, BuilderError> {
1865 let mut values = TreeMap::new();
1869 Some(ObjectEnd) => { return Ok(Object(values)); }
1870 Some(Error(e)) => { return Err(e); }
1874 let key = match self.parser.stack().top() {
1875 Some(Key(k)) => { k.to_string() }
1876 _ => { fail!("invalid state"); }
1878 match self.build_value() {
1879 Ok(value) => { values.insert(key, value); }
1880 Err(e) => { return Err(e); }
1884 return self.parser.error(EOFWhileParsingObject);
1888 /// Decodes a json value from an `&mut io::Reader`
1889 pub fn from_reader(rdr: &mut io::Reader) -> Result<Json, BuilderError> {
1890 let contents = match rdr.read_to_end() {
1892 Err(e) => return Err(io_error_to_error(e))
1894 let s = match str::from_utf8(contents.as_slice()) {
1896 _ => return Err(SyntaxError(NotUtf8, 0, 0))
1898 let mut builder = Builder::new(s.chars());
1902 /// Decodes a json value from a string
1903 pub fn from_str(s: &str) -> Result<Json, BuilderError> {
1904 let mut builder = Builder::new(s.chars());
1908 /// A structure to decode JSON to values in rust.
1909 pub struct Decoder {
1914 /// Creates a new decoder instance for decoding the specified JSON value.
1915 pub fn new(json: Json) -> Decoder {
1916 Decoder { stack: vec![json] }
1921 fn pop(&mut self) -> Json {
1922 self.stack.pop().unwrap()
1926 macro_rules! expect(
1927 ($e:expr, Null) => ({
1930 other => Err(ExpectedError("Null".to_string(),
1931 format!("{}", other)))
1934 ($e:expr, $t:ident) => ({
1938 Err(ExpectedError(stringify!($t).to_string(),
1939 format!("{}", other)))
1945 macro_rules! read_primitive {
1946 ($name:ident, $ty:ty) => {
1947 fn $name(&mut self) -> DecodeResult<$ty> {
1950 match num::cast(f) {
1952 None => Err(ExpectedError("Number".to_string(), format!("{}", f))),
1956 match num::cast(f) {
1958 None => Err(ExpectedError("Number".to_string(), format!("{}", f))),
1962 match num::cast(f) {
1964 None => Err(ExpectedError("Number".to_string(), format!("{}", f))),
1968 // re: #12967.. a type w/ numeric keys (ie HashMap<uint, V> etc)
1969 // is going to have a string here, as per JSON spec.
1970 match std::from_str::from_str(s.as_slice()) {
1972 None => Err(ExpectedError("Number".to_string(), s)),
1975 value => Err(ExpectedError("Number".to_string(), format!("{}", value)))
1981 impl ::Decoder<DecoderError> for Decoder {
1982 fn read_nil(&mut self) -> DecodeResult<()> {
1984 expect!(self.pop(), Null)
1987 read_primitive!(read_uint, uint)
1988 read_primitive!(read_u8, u8)
1989 read_primitive!(read_u16, u16)
1990 read_primitive!(read_u32, u32)
1991 read_primitive!(read_u64, u64)
1992 read_primitive!(read_int, int)
1993 read_primitive!(read_i8, i8)
1994 read_primitive!(read_i16, i16)
1995 read_primitive!(read_i32, i32)
1996 read_primitive!(read_i64, i64)
1998 fn read_f32(&mut self) -> DecodeResult<f32> { self.read_f64().map(|x| x as f32) }
2000 fn read_f64(&mut self) -> DecodeResult<f64> {
2003 I64(f) => Ok(f as f64),
2004 U64(f) => Ok(f as f64),
2007 // re: #12967.. a type w/ numeric keys (ie HashMap<uint, V> etc)
2008 // is going to have a string here, as per JSON spec.
2009 match std::from_str::from_str(s.as_slice()) {
2011 None => Err(ExpectedError("Number".to_string(), s)),
2014 Null => Ok(f64::NAN),
2015 value => Err(ExpectedError("Number".to_string(), format!("{}", value)))
2019 fn read_bool(&mut self) -> DecodeResult<bool> {
2020 debug!("read_bool");
2021 expect!(self.pop(), Boolean)
2024 fn read_char(&mut self) -> DecodeResult<char> {
2025 let s = try!(self.read_str());
2027 let mut it = s.as_slice().chars();
2028 match (it.next(), it.next()) {
2029 // exactly one character
2030 (Some(c), None) => return Ok(c),
2034 Err(ExpectedError("single character string".to_string(), format!("{}", s)))
2037 fn read_str(&mut self) -> DecodeResult<string::String> {
2039 expect!(self.pop(), String)
2042 fn read_enum<T>(&mut self,
2044 f: |&mut Decoder| -> DecodeResult<T>) -> DecodeResult<T> {
2045 debug!("read_enum({})", name);
2049 fn read_enum_variant<T>(&mut self,
2051 f: |&mut Decoder, uint| -> DecodeResult<T>)
2052 -> DecodeResult<T> {
2053 debug!("read_enum_variant(names={})", names);
2054 let name = match self.pop() {
2057 let n = match o.pop(&"variant".to_string()) {
2058 Some(String(s)) => s,
2060 return Err(ExpectedError("String".to_string(), format!("{}", val)))
2063 return Err(MissingFieldError("variant".to_string()))
2066 match o.pop(&"fields".to_string()) {
2068 for field in l.into_iter().rev() {
2069 self.stack.push(field);
2073 return Err(ExpectedError("List".to_string(), format!("{}", val)))
2076 return Err(MissingFieldError("fields".to_string()))
2082 return Err(ExpectedError("String or Object".to_string(), format!("{}", json)))
2085 let idx = match names.iter()
2086 .position(|n| str::eq_slice(*n, name.as_slice())) {
2088 None => return Err(UnknownVariantError(name))
2093 fn read_enum_variant_arg<T>(&mut self, idx: uint, f: |&mut Decoder| -> DecodeResult<T>)
2094 -> DecodeResult<T> {
2095 debug!("read_enum_variant_arg(idx={})", idx);
2099 fn read_enum_struct_variant<T>(&mut self,
2101 f: |&mut Decoder, uint| -> DecodeResult<T>)
2102 -> DecodeResult<T> {
2103 debug!("read_enum_struct_variant(names={})", names);
2104 self.read_enum_variant(names, f)
2108 fn read_enum_struct_variant_field<T>(&mut self,
2111 f: |&mut Decoder| -> DecodeResult<T>)
2112 -> DecodeResult<T> {
2113 debug!("read_enum_struct_variant_field(name={}, idx={})", name, idx);
2114 self.read_enum_variant_arg(idx, f)
2117 fn read_struct<T>(&mut self,
2120 f: |&mut Decoder| -> DecodeResult<T>)
2121 -> DecodeResult<T> {
2122 debug!("read_struct(name={}, len={})", name, len);
2123 let value = try!(f(self));
2128 fn read_struct_field<T>(&mut self,
2131 f: |&mut Decoder| -> DecodeResult<T>)
2132 -> DecodeResult<T> {
2133 debug!("read_struct_field(name={}, idx={})", name, idx);
2134 let mut obj = try!(expect!(self.pop(), Object));
2136 let value = match obj.pop(&name.to_string()) {
2138 // Add a Null and try to parse it as an Option<_>
2139 // to get None as a default value.
2140 self.stack.push(Null);
2143 Err(_) => return Err(MissingFieldError(name.to_string())),
2147 self.stack.push(json);
2151 self.stack.push(Object(obj));
2155 fn read_tuple<T>(&mut self, f: |&mut Decoder, uint| -> DecodeResult<T>) -> DecodeResult<T> {
2156 debug!("read_tuple()");
2160 fn read_tuple_arg<T>(&mut self,
2162 f: |&mut Decoder| -> DecodeResult<T>) -> DecodeResult<T> {
2163 debug!("read_tuple_arg(idx={})", idx);
2164 self.read_seq_elt(idx, f)
2167 fn read_tuple_struct<T>(&mut self,
2169 f: |&mut Decoder, uint| -> DecodeResult<T>)
2170 -> DecodeResult<T> {
2171 debug!("read_tuple_struct(name={})", name);
2175 fn read_tuple_struct_arg<T>(&mut self,
2177 f: |&mut Decoder| -> DecodeResult<T>)
2178 -> DecodeResult<T> {
2179 debug!("read_tuple_struct_arg(idx={})", idx);
2180 self.read_tuple_arg(idx, f)
2183 fn read_option<T>(&mut self, f: |&mut Decoder, bool| -> DecodeResult<T>) -> DecodeResult<T> {
2184 debug!("read_option()");
2186 Null => f(self, false),
2187 value => { self.stack.push(value); f(self, true) }
2191 fn read_seq<T>(&mut self, f: |&mut Decoder, uint| -> DecodeResult<T>) -> DecodeResult<T> {
2192 debug!("read_seq()");
2193 let list = try!(expect!(self.pop(), List));
2194 let len = list.len();
2195 for v in list.into_iter().rev() {
2201 fn read_seq_elt<T>(&mut self,
2203 f: |&mut Decoder| -> DecodeResult<T>) -> DecodeResult<T> {
2204 debug!("read_seq_elt(idx={})", idx);
2208 fn read_map<T>(&mut self, f: |&mut Decoder, uint| -> DecodeResult<T>) -> DecodeResult<T> {
2209 debug!("read_map()");
2210 let obj = try!(expect!(self.pop(), Object));
2211 let len = obj.len();
2212 for (key, value) in obj.into_iter() {
2213 self.stack.push(value);
2214 self.stack.push(String(key));
2219 fn read_map_elt_key<T>(&mut self, idx: uint, f: |&mut Decoder| -> DecodeResult<T>)
2220 -> DecodeResult<T> {
2221 debug!("read_map_elt_key(idx={})", idx);
2225 fn read_map_elt_val<T>(&mut self, idx: uint, f: |&mut Decoder| -> DecodeResult<T>)
2226 -> DecodeResult<T> {
2227 debug!("read_map_elt_val(idx={})", idx);
2231 fn error(&mut self, err: &str) -> DecoderError {
2232 ApplicationError(err.to_string())
2236 /// A trait for converting values to JSON
2238 /// Converts the value of `self` to an instance of JSON
2239 fn to_json(&self) -> Json;
2242 macro_rules! to_json_impl_i64(
2244 $(impl ToJson for $t {
2245 fn to_json(&self) -> Json { I64(*self as i64) }
2250 to_json_impl_i64!(int, i8, i16, i32, i64)
2252 macro_rules! to_json_impl_u64(
2254 $(impl ToJson for $t {
2255 fn to_json(&self) -> Json { U64(*self as u64) }
2260 to_json_impl_u64!(uint, u8, u16, u32, u64)
2262 impl ToJson for Json {
2263 fn to_json(&self) -> Json { self.clone() }
2266 impl ToJson for f32 {
2267 fn to_json(&self) -> Json { (*self as f64).to_json() }
2270 impl ToJson for f64 {
2271 fn to_json(&self) -> Json {
2272 match self.classify() {
2273 FPNaN | FPInfinite => Null,
2279 impl ToJson for () {
2280 fn to_json(&self) -> Json { Null }
2283 impl ToJson for bool {
2284 fn to_json(&self) -> Json { Boolean(*self) }
2287 impl ToJson for string::String {
2288 fn to_json(&self) -> Json { String((*self).clone()) }
2291 macro_rules! tuple_impl {
2292 // use variables to indicate the arity of the tuple
2293 ($($tyvar:ident),* ) => {
2294 // the trailing commas are for the 1 tuple
2296 $( $tyvar : ToJson ),*
2297 > ToJson for ( $( $tyvar ),* , ) {
2300 #[allow(non_snake_case)]
2301 fn to_json(&self) -> Json {
2303 ($(ref $tyvar),*,) => List(vec![$($tyvar.to_json()),*])
2312 tuple_impl!{A, B, C}
2313 tuple_impl!{A, B, C, D}
2314 tuple_impl!{A, B, C, D, E}
2315 tuple_impl!{A, B, C, D, E, F}
2316 tuple_impl!{A, B, C, D, E, F, G}
2317 tuple_impl!{A, B, C, D, E, F, G, H}
2318 tuple_impl!{A, B, C, D, E, F, G, H, I}
2319 tuple_impl!{A, B, C, D, E, F, G, H, I, J}
2320 tuple_impl!{A, B, C, D, E, F, G, H, I, J, K}
2321 tuple_impl!{A, B, C, D, E, F, G, H, I, J, K, L}
2323 impl<'a, A: ToJson> ToJson for &'a [A] {
2324 fn to_json(&self) -> Json { List(self.iter().map(|elt| elt.to_json()).collect()) }
2327 impl<A: ToJson> ToJson for Vec<A> {
2328 fn to_json(&self) -> Json { List(self.iter().map(|elt| elt.to_json()).collect()) }
2331 impl<A: ToJson> ToJson for TreeMap<string::String, A> {
2332 fn to_json(&self) -> Json {
2333 let mut d = TreeMap::new();
2334 for (key, value) in self.iter() {
2335 d.insert((*key).clone(), value.to_json());
2341 impl<A: ToJson> ToJson for HashMap<string::String, A> {
2342 fn to_json(&self) -> Json {
2343 let mut d = TreeMap::new();
2344 for (key, value) in self.iter() {
2345 d.insert((*key).clone(), value.to_json());
2351 impl<A:ToJson> ToJson for Option<A> {
2352 fn to_json(&self) -> Json {
2355 Some(ref value) => value.to_json()
2360 impl fmt::Show for Json {
2361 /// Encodes a json value into a string
2362 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2363 self.to_writer(f).map_err(|_| fmt::WriteError)
2367 impl std::from_str::FromStr for Json {
2368 fn from_str(s: &str) -> Option<Json> {
2376 use self::test::Bencher;
2377 use {Encodable, Decodable};
2378 use super::{List, Encoder, Decoder, Error, Boolean, I64, U64, F64, String, Null,
2379 PrettyEncoder, Object, Json, from_str, ParseError, ExpectedError,
2380 MissingFieldError, UnknownVariantError, DecodeResult, DecoderError,
2381 JsonEvent, Parser, StackElement,
2382 ObjectStart, ObjectEnd, ListStart, ListEnd, BooleanValue, U64Value,
2383 F64Value, StringValue, NullValue, SyntaxError, Key, Index, Stack,
2384 InvalidSyntax, InvalidNumber, EOFWhileParsingObject, EOFWhileParsingList,
2385 EOFWhileParsingValue, EOFWhileParsingString, KeyMustBeAString, ExpectedColon,
2386 TrailingCharacters, TrailingComma};
2387 use std::{i64, u64, f32, f64, io};
2388 use std::collections::TreeMap;
2391 #[deriving(Decodable, Eq, PartialEq, Show)]
2397 fn test_decode_option_none() {
2399 let obj: OptionData = super::decode(s).unwrap();
2400 assert_eq!(obj, OptionData { opt: None });
2404 fn test_decode_option_some() {
2405 let s = "{ \"opt\": 10 }";
2406 let obj: OptionData = super::decode(s).unwrap();
2407 assert_eq!(obj, OptionData { opt: Some(10u) });
2411 fn test_decode_option_malformed() {
2412 check_err::<OptionData>("{ \"opt\": [] }",
2413 ExpectedError("Number".to_string(), "[]".to_string()));
2414 check_err::<OptionData>("{ \"opt\": false }",
2415 ExpectedError("Number".to_string(), "false".to_string()));
2418 #[deriving(PartialEq, Encodable, Decodable, Show)]
2421 Frog(string::String, int)
2424 #[deriving(PartialEq, Encodable, Decodable, Show)]
2428 c: Vec<string::String>,
2431 #[deriving(PartialEq, Encodable, Decodable, Show)]
2436 fn mk_object(items: &[(string::String, Json)]) -> Json {
2437 let mut d = TreeMap::new();
2439 for item in items.iter() {
2441 (ref key, ref value) => { d.insert((*key).clone(), (*value).clone()); },
2449 fn test_from_str_trait() {
2451 assert!(::std::from_str::from_str::<Json>(s).unwrap() == from_str(s).unwrap());
2455 fn test_write_null() {
2456 assert_eq!(Null.to_string().into_string(), "null".to_string());
2457 assert_eq!(Null.to_pretty_str().into_string(), "null".to_string());
2461 fn test_write_i64() {
2462 assert_eq!(U64(0).to_string().into_string(), "0".to_string());
2463 assert_eq!(U64(0).to_pretty_str().into_string(), "0".to_string());
2465 assert_eq!(U64(1234).to_string().into_string(), "1234".to_string());
2466 assert_eq!(U64(1234).to_pretty_str().into_string(), "1234".to_string());
2468 assert_eq!(I64(-5678).to_string().into_string(), "-5678".to_string());
2469 assert_eq!(I64(-5678).to_pretty_str().into_string(), "-5678".to_string());
2473 fn test_write_f64() {
2474 assert_eq!(F64(3.0).to_string().into_string(), "3".to_string());
2475 assert_eq!(F64(3.0).to_pretty_str().into_string(), "3".to_string());
2477 assert_eq!(F64(3.1).to_string().into_string(), "3.1".to_string());
2478 assert_eq!(F64(3.1).to_pretty_str().into_string(), "3.1".to_string());
2480 assert_eq!(F64(-1.5).to_string().into_string(), "-1.5".to_string());
2481 assert_eq!(F64(-1.5).to_pretty_str().into_string(), "-1.5".to_string());
2483 assert_eq!(F64(0.5).to_string().into_string(), "0.5".to_string());
2484 assert_eq!(F64(0.5).to_pretty_str().into_string(), "0.5".to_string());
2486 assert_eq!(F64(f64::NAN).to_string().into_string(), "null".to_string());
2487 assert_eq!(F64(f64::NAN).to_pretty_str().into_string(), "null".to_string());
2489 assert_eq!(F64(f64::INFINITY).to_string().into_string(), "null".to_string());
2490 assert_eq!(F64(f64::INFINITY).to_pretty_str().into_string(), "null".to_string());
2492 assert_eq!(F64(f64::NEG_INFINITY).to_string().into_string(), "null".to_string());
2493 assert_eq!(F64(f64::NEG_INFINITY).to_pretty_str().into_string(), "null".to_string());
2497 fn test_write_str() {
2498 assert_eq!(String("".to_string()).to_string().into_string(), "\"\"".to_string());
2499 assert_eq!(String("".to_string()).to_pretty_str().into_string(), "\"\"".to_string());
2501 assert_eq!(String("foo".to_string()).to_string().into_string(), "\"foo\"".to_string());
2502 assert_eq!(String("foo".to_string()).to_pretty_str().into_string(), "\"foo\"".to_string());
2506 fn test_write_bool() {
2507 assert_eq!(Boolean(true).to_string().into_string(), "true".to_string());
2508 assert_eq!(Boolean(true).to_pretty_str().into_string(), "true".to_string());
2510 assert_eq!(Boolean(false).to_string().into_string(), "false".to_string());
2511 assert_eq!(Boolean(false).to_pretty_str().into_string(), "false".to_string());
2515 fn test_write_list() {
2516 assert_eq!(List(vec![]).to_string().into_string(), "[]".to_string());
2517 assert_eq!(List(vec![]).to_pretty_str().into_string(), "[]".to_string());
2519 assert_eq!(List(vec![Boolean(true)]).to_string().into_string(), "[true]".to_string());
2521 List(vec![Boolean(true)]).to_pretty_str().into_string(),
2528 let long_test_list = List(vec![
2531 List(vec![String("foo\nbar".to_string()), F64(3.5)])]);
2533 assert_eq!(long_test_list.to_string().into_string(),
2534 "[false,null,[\"foo\\nbar\",3.5]]".to_string());
2536 long_test_list.to_pretty_str().into_string(),
2550 fn test_write_object() {
2551 assert_eq!(mk_object([]).to_string().into_string(), "{}".to_string());
2552 assert_eq!(mk_object([]).to_pretty_str().into_string(), "{}".to_string());
2556 ("a".to_string(), Boolean(true))
2557 ]).to_string().into_string(),
2558 "{\"a\":true}".to_string()
2561 mk_object([("a".to_string(), Boolean(true))]).to_pretty_str(),
2568 let complex_obj = mk_object([
2569 ("b".to_string(), List(vec![
2570 mk_object([("c".to_string(), String("\x0c\r".to_string()))]),
2571 mk_object([("d".to_string(), String("".to_string()))])
2576 complex_obj.to_string().into_string(),
2579 {\"c\":\"\\f\\r\"},\
2585 complex_obj.to_pretty_str().into_string(),
2590 \"c\": \"\\f\\r\"\n \
2600 ("a".to_string(), Boolean(true)),
2601 ("b".to_string(), List(vec![
2602 mk_object([("c".to_string(), String("\x0c\r".to_string()))]),
2603 mk_object([("d".to_string(), String("".to_string()))])
2607 // We can't compare the strings directly because the object fields be
2608 // printed in a different order.
2609 assert_eq!(a.clone(), from_str(a.to_string().as_slice()).unwrap());
2610 assert_eq!(a.clone(),
2611 from_str(a.to_pretty_str().as_slice()).unwrap());
2614 fn with_str_writer(f: |&mut io::Writer|) -> string::String {
2615 use std::io::MemWriter;
2618 let mut m = MemWriter::new();
2619 f(&mut m as &mut io::Writer);
2620 str::from_utf8(m.unwrap().as_slice()).unwrap().to_string()
2624 fn test_write_enum() {
2627 with_str_writer(|writer| {
2628 let mut encoder = Encoder::new(writer);
2629 animal.encode(&mut encoder).unwrap();
2631 "\"Dog\"".to_string()
2634 with_str_writer(|writer| {
2635 let mut encoder = PrettyEncoder::new(writer);
2636 animal.encode(&mut encoder).unwrap();
2638 "\"Dog\"".to_string()
2641 let animal = Frog("Henry".to_string(), 349);
2643 with_str_writer(|writer| {
2644 let mut encoder = Encoder::new(writer);
2645 animal.encode(&mut encoder).unwrap();
2647 "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}".to_string()
2650 with_str_writer(|writer| {
2651 let mut encoder = PrettyEncoder::new(writer);
2652 animal.encode(&mut encoder).unwrap();
2664 fn test_write_some() {
2665 let value = Some("jodhpurs".to_string());
2666 let s = with_str_writer(|writer| {
2667 let mut encoder = Encoder::new(writer);
2668 value.encode(&mut encoder).unwrap();
2670 assert_eq!(s, "\"jodhpurs\"".to_string());
2672 let value = Some("jodhpurs".to_string());
2673 let s = with_str_writer(|writer| {
2674 let mut encoder = PrettyEncoder::new(writer);
2675 value.encode(&mut encoder).unwrap();
2677 assert_eq!(s, "\"jodhpurs\"".to_string());
2681 fn test_write_none() {
2682 let value: Option<string::String> = None;
2683 let s = with_str_writer(|writer| {
2684 let mut encoder = Encoder::new(writer);
2685 value.encode(&mut encoder).unwrap();
2687 assert_eq!(s, "null".to_string());
2689 let s = with_str_writer(|writer| {
2690 let mut encoder = Encoder::new(writer);
2691 value.encode(&mut encoder).unwrap();
2693 assert_eq!(s, "null".to_string());
2697 fn test_trailing_characters() {
2698 assert_eq!(from_str("nulla"), Err(SyntaxError(TrailingCharacters, 1, 5)));
2699 assert_eq!(from_str("truea"), Err(SyntaxError(TrailingCharacters, 1, 5)));
2700 assert_eq!(from_str("falsea"), Err(SyntaxError(TrailingCharacters, 1, 6)));
2701 assert_eq!(from_str("1a"), Err(SyntaxError(TrailingCharacters, 1, 2)));
2702 assert_eq!(from_str("[]a"), Err(SyntaxError(TrailingCharacters, 1, 3)));
2703 assert_eq!(from_str("{}a"), Err(SyntaxError(TrailingCharacters, 1, 3)));
2707 fn test_read_identifiers() {
2708 assert_eq!(from_str("n"), Err(SyntaxError(InvalidSyntax, 1, 2)));
2709 assert_eq!(from_str("nul"), Err(SyntaxError(InvalidSyntax, 1, 4)));
2710 assert_eq!(from_str("t"), Err(SyntaxError(InvalidSyntax, 1, 2)));
2711 assert_eq!(from_str("truz"), Err(SyntaxError(InvalidSyntax, 1, 4)));
2712 assert_eq!(from_str("f"), Err(SyntaxError(InvalidSyntax, 1, 2)));
2713 assert_eq!(from_str("faz"), Err(SyntaxError(InvalidSyntax, 1, 3)));
2715 assert_eq!(from_str("null"), Ok(Null));
2716 assert_eq!(from_str("true"), Ok(Boolean(true)));
2717 assert_eq!(from_str("false"), Ok(Boolean(false)));
2718 assert_eq!(from_str(" null "), Ok(Null));
2719 assert_eq!(from_str(" true "), Ok(Boolean(true)));
2720 assert_eq!(from_str(" false "), Ok(Boolean(false)));
2724 fn test_decode_identifiers() {
2725 let v: () = super::decode("null").unwrap();
2728 let v: bool = super::decode("true").unwrap();
2729 assert_eq!(v, true);
2731 let v: bool = super::decode("false").unwrap();
2732 assert_eq!(v, false);
2736 fn test_read_number() {
2737 assert_eq!(from_str("+"), Err(SyntaxError(InvalidSyntax, 1, 1)));
2738 assert_eq!(from_str("."), Err(SyntaxError(InvalidSyntax, 1, 1)));
2739 assert_eq!(from_str("NaN"), Err(SyntaxError(InvalidSyntax, 1, 1)));
2740 assert_eq!(from_str("-"), Err(SyntaxError(InvalidNumber, 1, 2)));
2741 assert_eq!(from_str("00"), Err(SyntaxError(InvalidNumber, 1, 2)));
2742 assert_eq!(from_str("1."), Err(SyntaxError(InvalidNumber, 1, 3)));
2743 assert_eq!(from_str("1e"), Err(SyntaxError(InvalidNumber, 1, 3)));
2744 assert_eq!(from_str("1e+"), Err(SyntaxError(InvalidNumber, 1, 4)));
2746 assert_eq!(from_str("18446744073709551616"), Err(SyntaxError(InvalidNumber, 1, 20)));
2747 assert_eq!(from_str("-9223372036854775809"), Err(SyntaxError(InvalidNumber, 1, 21)));
2749 assert_eq!(from_str("3"), Ok(U64(3)));
2750 assert_eq!(from_str("3.1"), Ok(F64(3.1)));
2751 assert_eq!(from_str("-1.2"), Ok(F64(-1.2)));
2752 assert_eq!(from_str("0.4"), Ok(F64(0.4)));
2753 assert_eq!(from_str("0.4e5"), Ok(F64(0.4e5)));
2754 assert_eq!(from_str("0.4e+15"), Ok(F64(0.4e15)));
2755 assert_eq!(from_str("0.4e-01"), Ok(F64(0.4e-01)));
2756 assert_eq!(from_str(" 3 "), Ok(U64(3)));
2758 assert_eq!(from_str("-9223372036854775808"), Ok(I64(i64::MIN)));
2759 assert_eq!(from_str("9223372036854775807"), Ok(U64(i64::MAX as u64)));
2760 assert_eq!(from_str("18446744073709551615"), Ok(U64(u64::MAX)));
2764 fn test_decode_numbers() {
2765 let v: f64 = super::decode("3").unwrap();
2768 let v: f64 = super::decode("3.1").unwrap();
2771 let v: f64 = super::decode("-1.2").unwrap();
2772 assert_eq!(v, -1.2);
2774 let v: f64 = super::decode("0.4").unwrap();
2777 let v: f64 = super::decode("0.4e5").unwrap();
2778 assert_eq!(v, 0.4e5);
2780 let v: f64 = super::decode("0.4e15").unwrap();
2781 assert_eq!(v, 0.4e15);
2783 let v: f64 = super::decode("0.4e-01").unwrap();
2784 assert_eq!(v, 0.4e-01);
2786 let v: u64 = super::decode("0").unwrap();
2789 let v: u64 = super::decode("18446744073709551615").unwrap();
2790 assert_eq!(v, u64::MAX);
2792 let v: i64 = super::decode("-9223372036854775808").unwrap();
2793 assert_eq!(v, i64::MIN);
2795 let v: i64 = super::decode("9223372036854775807").unwrap();
2796 assert_eq!(v, i64::MAX);
2800 fn test_read_str() {
2801 assert_eq!(from_str("\""), Err(SyntaxError(EOFWhileParsingString, 1, 2)));
2802 assert_eq!(from_str("\"lol"), Err(SyntaxError(EOFWhileParsingString, 1, 5)));
2804 assert_eq!(from_str("\"\""), Ok(String("".to_string())));
2805 assert_eq!(from_str("\"foo\""), Ok(String("foo".to_string())));
2806 assert_eq!(from_str("\"\\\"\""), Ok(String("\"".to_string())));
2807 assert_eq!(from_str("\"\\b\""), Ok(String("\x08".to_string())));
2808 assert_eq!(from_str("\"\\n\""), Ok(String("\n".to_string())));
2809 assert_eq!(from_str("\"\\r\""), Ok(String("\r".to_string())));
2810 assert_eq!(from_str("\"\\t\""), Ok(String("\t".to_string())));
2811 assert_eq!(from_str(" \"foo\" "), Ok(String("foo".to_string())));
2812 assert_eq!(from_str("\"\\u12ab\""), Ok(String("\u12ab".to_string())));
2813 assert_eq!(from_str("\"\\uAB12\""), Ok(String("\uAB12".to_string())));
2817 fn test_decode_str() {
2818 let s = [("\"\"", ""),
2821 ("\"\\b\"", "\x08"),
2825 ("\"\\u12ab\"", "\u12ab"),
2826 ("\"\\uAB12\"", "\uAB12")];
2828 for &(i, o) in s.iter() {
2829 let v: string::String = super::decode(i).unwrap();
2830 assert_eq!(v.as_slice(), o);
2835 fn test_read_list() {
2836 assert_eq!(from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
2837 assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingList, 1, 3)));
2838 assert_eq!(from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
2839 assert_eq!(from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
2840 assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
2842 assert_eq!(from_str("[]"), Ok(List(vec![])));
2843 assert_eq!(from_str("[ ]"), Ok(List(vec![])));
2844 assert_eq!(from_str("[true]"), Ok(List(vec![Boolean(true)])));
2845 assert_eq!(from_str("[ false ]"), Ok(List(vec![Boolean(false)])));
2846 assert_eq!(from_str("[null]"), Ok(List(vec![Null])));
2847 assert_eq!(from_str("[3, 1]"),
2848 Ok(List(vec![U64(3), U64(1)])));
2849 assert_eq!(from_str("\n[3, 2]\n"),
2850 Ok(List(vec![U64(3), U64(2)])));
2851 assert_eq!(from_str("[2, [4, 1]]"),
2852 Ok(List(vec![U64(2), List(vec![U64(4), U64(1)])])));
2856 fn test_decode_list() {
2857 let v: Vec<()> = super::decode("[]").unwrap();
2858 assert_eq!(v, vec![]);
2860 let v: Vec<()> = super::decode("[null]").unwrap();
2861 assert_eq!(v, vec![()]);
2863 let v: Vec<bool> = super::decode("[true]").unwrap();
2864 assert_eq!(v, vec![true]);
2866 let v: Vec<int> = super::decode("[3, 1]").unwrap();
2867 assert_eq!(v, vec![3, 1]);
2869 let v: Vec<Vec<uint>> = super::decode("[[3], [1, 2]]").unwrap();
2870 assert_eq!(v, vec![vec![3], vec![1, 2]]);
2874 fn test_read_object() {
2875 assert_eq!(from_str("{"), Err(SyntaxError(EOFWhileParsingObject, 1, 2)));
2876 assert_eq!(from_str("{ "), Err(SyntaxError(EOFWhileParsingObject, 1, 3)));
2877 assert_eq!(from_str("{1"), Err(SyntaxError(KeyMustBeAString, 1, 2)));
2878 assert_eq!(from_str("{ \"a\""), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
2879 assert_eq!(from_str("{\"a\""), Err(SyntaxError(EOFWhileParsingObject, 1, 5)));
2880 assert_eq!(from_str("{\"a\" "), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
2882 assert_eq!(from_str("{\"a\" 1"), Err(SyntaxError(ExpectedColon, 1, 6)));
2883 assert_eq!(from_str("{\"a\":"), Err(SyntaxError(EOFWhileParsingValue, 1, 6)));
2884 assert_eq!(from_str("{\"a\":1"), Err(SyntaxError(EOFWhileParsingObject, 1, 7)));
2885 assert_eq!(from_str("{\"a\":1 1"), Err(SyntaxError(InvalidSyntax, 1, 8)));
2886 assert_eq!(from_str("{\"a\":1,"), Err(SyntaxError(EOFWhileParsingObject, 1, 8)));
2888 assert_eq!(from_str("{}").unwrap(), mk_object([]));
2889 assert_eq!(from_str("{\"a\": 3}").unwrap(),
2890 mk_object([("a".to_string(), U64(3))]));
2892 assert_eq!(from_str(
2893 "{ \"a\": null, \"b\" : true }").unwrap(),
2895 ("a".to_string(), Null),
2896 ("b".to_string(), Boolean(true))]));
2897 assert_eq!(from_str("\n{ \"a\": null, \"b\" : true }\n").unwrap(),
2899 ("a".to_string(), Null),
2900 ("b".to_string(), Boolean(true))]));
2901 assert_eq!(from_str(
2902 "{\"a\" : 1.0 ,\"b\": [ true ]}").unwrap(),
2904 ("a".to_string(), F64(1.0)),
2905 ("b".to_string(), List(vec![Boolean(true)]))
2907 assert_eq!(from_str(
2913 { \"c\": {\"d\": null} } \
2917 ("a".to_string(), F64(1.0)),
2918 ("b".to_string(), List(vec![
2920 String("foo\nbar".to_string()),
2922 ("c".to_string(), mk_object([("d".to_string(), Null)]))
2929 fn test_decode_struct() {
2932 { \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] }
2936 let v: Outer = super::decode(s).unwrap();
2941 Inner { a: (), b: 2, c: vec!["abc".to_string(), "xyz".to_string()] }
2947 #[deriving(Decodable)]
2948 struct FloatStruct {
2953 fn test_decode_struct_with_nan() {
2954 let s = "{\"f\":null,\"a\":[null,123]}";
2955 let obj: FloatStruct = super::decode(s).unwrap();
2956 assert!(obj.f.is_nan());
2957 assert!(obj.a.get(0).is_nan());
2958 assert_eq!(obj.a.get(1), &123f64);
2962 fn test_decode_option() {
2963 let value: Option<string::String> = super::decode("null").unwrap();
2964 assert_eq!(value, None);
2966 let value: Option<string::String> = super::decode("\"jodhpurs\"").unwrap();
2967 assert_eq!(value, Some("jodhpurs".to_string()));
2971 fn test_decode_enum() {
2972 let value: Animal = super::decode("\"Dog\"").unwrap();
2973 assert_eq!(value, Dog);
2975 let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}";
2976 let value: Animal = super::decode(s).unwrap();
2977 assert_eq!(value, Frog("Henry".to_string(), 349));
2981 fn test_decode_map() {
2982 let s = "{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\
2983 \"fields\":[\"Henry\", 349]}}";
2984 let mut map: TreeMap<string::String, Animal> = super::decode(s).unwrap();
2986 assert_eq!(map.pop(&"a".to_string()), Some(Dog));
2987 assert_eq!(map.pop(&"b".to_string()), Some(Frog("Henry".to_string(), 349)));
2991 fn test_multiline_errors() {
2992 assert_eq!(from_str("{\n \"foo\":\n \"bar\""),
2993 Err(SyntaxError(EOFWhileParsingObject, 3u, 8u)));
2996 #[deriving(Decodable)]
2998 struct DecodeStruct {
3002 w: Vec<DecodeStruct>
3004 #[deriving(Decodable)]
3009 fn check_err<T: Decodable<Decoder, DecoderError>>(to_parse: &'static str,
3010 expected: DecoderError) {
3011 let res: DecodeResult<T> = match from_str(to_parse) {
3012 Err(e) => Err(ParseError(e)),
3013 Ok(json) => Decodable::decode(&mut Decoder::new(json))
3016 Ok(_) => fail!("`{}` parsed & decoded ok, expecting error `{}`",
3017 to_parse, expected),
3018 Err(ParseError(e)) => fail!("`{}` is not valid json: {}",
3021 assert_eq!(e, expected);
3026 fn test_decode_errors_struct() {
3027 check_err::<DecodeStruct>("[]", ExpectedError("Object".to_string(), "[]".to_string()));
3028 check_err::<DecodeStruct>("{\"x\": true, \"y\": true, \"z\": \"\", \"w\": []}",
3029 ExpectedError("Number".to_string(), "true".to_string()));
3030 check_err::<DecodeStruct>("{\"x\": 1, \"y\": [], \"z\": \"\", \"w\": []}",
3031 ExpectedError("Boolean".to_string(), "[]".to_string()));
3032 check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": {}, \"w\": []}",
3033 ExpectedError("String".to_string(), "{}".to_string()));
3034 check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\", \"w\": null}",
3035 ExpectedError("List".to_string(), "null".to_string()));
3036 check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\"}",
3037 MissingFieldError("w".to_string()));
3040 fn test_decode_errors_enum() {
3041 check_err::<DecodeEnum>("{}",
3042 MissingFieldError("variant".to_string()));
3043 check_err::<DecodeEnum>("{\"variant\": 1}",
3044 ExpectedError("String".to_string(), "1".to_string()));
3045 check_err::<DecodeEnum>("{\"variant\": \"A\"}",
3046 MissingFieldError("fields".to_string()));
3047 check_err::<DecodeEnum>("{\"variant\": \"A\", \"fields\": null}",
3048 ExpectedError("List".to_string(), "null".to_string()));
3049 check_err::<DecodeEnum>("{\"variant\": \"C\", \"fields\": []}",
3050 UnknownVariantError("C".to_string()));
3055 let json_value = from_str("{\"dog\" : \"cat\"}").unwrap();
3056 let found_str = json_value.find(&"dog".to_string());
3057 assert!(found_str.is_some() && found_str.unwrap().as_string().unwrap() == "cat");
3061 fn test_find_path(){
3062 let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap();
3063 let found_str = json_value.find_path(&[&"dog".to_string(),
3064 &"cat".to_string(), &"mouse".to_string()]);
3065 assert!(found_str.is_some() && found_str.unwrap().as_string().unwrap() == "cheese");
3070 let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap();
3071 let found_str = json_value.search(&"mouse".to_string()).and_then(|j| j.as_string());
3072 assert!(found_str.is_some());
3073 assert!(found_str.unwrap() == "cheese");
3077 fn test_is_object(){
3078 let json_value = from_str("{}").unwrap();
3079 assert!(json_value.is_object());
3083 fn test_as_object(){
3084 let json_value = from_str("{}").unwrap();
3085 let json_object = json_value.as_object();
3086 assert!(json_object.is_some());
3091 let json_value = from_str("[1, 2, 3]").unwrap();
3092 assert!(json_value.is_list());
3097 let json_value = from_str("[1, 2, 3]").unwrap();
3098 let json_list = json_value.as_list();
3099 let expected_length = 3;
3100 assert!(json_list.is_some() && json_list.unwrap().len() == expected_length);
3104 fn test_is_string(){
3105 let json_value = from_str("\"dog\"").unwrap();
3106 assert!(json_value.is_string());
3110 fn test_as_string(){
3111 let json_value = from_str("\"dog\"").unwrap();
3112 let json_str = json_value.as_string();
3113 let expected_str = "dog";
3114 assert_eq!(json_str, Some(expected_str));
3118 fn test_is_number(){
3119 let json_value = from_str("12").unwrap();
3120 assert!(json_value.is_number());
3125 let json_value = from_str("-12").unwrap();
3126 assert!(json_value.is_i64());
3128 let json_value = from_str("12").unwrap();
3129 assert!(!json_value.is_i64());
3131 let json_value = from_str("12.0").unwrap();
3132 assert!(!json_value.is_i64());
3137 let json_value = from_str("12").unwrap();
3138 assert!(json_value.is_u64());
3140 let json_value = from_str("-12").unwrap();
3141 assert!(!json_value.is_u64());
3143 let json_value = from_str("12.0").unwrap();
3144 assert!(!json_value.is_u64());
3149 let json_value = from_str("12").unwrap();
3150 assert!(!json_value.is_f64());
3152 let json_value = from_str("-12").unwrap();
3153 assert!(!json_value.is_f64());
3155 let json_value = from_str("12.0").unwrap();
3156 assert!(json_value.is_f64());
3158 let json_value = from_str("-12.0").unwrap();
3159 assert!(json_value.is_f64());
3164 let json_value = from_str("-12").unwrap();
3165 let json_num = json_value.as_i64();
3166 assert_eq!(json_num, Some(-12));
3171 let json_value = from_str("12").unwrap();
3172 let json_num = json_value.as_u64();
3173 assert_eq!(json_num, Some(12));
3178 let json_value = from_str("12.0").unwrap();
3179 let json_num = json_value.as_f64();
3180 assert_eq!(json_num, Some(12f64));
3184 fn test_is_boolean(){
3185 let json_value = from_str("false").unwrap();
3186 assert!(json_value.is_boolean());
3190 fn test_as_boolean(){
3191 let json_value = from_str("false").unwrap();
3192 let json_bool = json_value.as_boolean();
3193 let expected_bool = false;
3194 assert!(json_bool.is_some() && json_bool.unwrap() == expected_bool);
3199 let json_value = from_str("null").unwrap();
3200 assert!(json_value.is_null());
3205 let json_value = from_str("null").unwrap();
3206 let json_null = json_value.as_null();
3207 let expected_null = ();
3208 assert!(json_null.is_some() && json_null.unwrap() == expected_null);
3212 fn test_encode_hashmap_with_numeric_key() {
3213 use std::str::from_utf8;
3214 use std::io::Writer;
3215 use std::io::MemWriter;
3216 use std::collections::HashMap;
3217 let mut hm: HashMap<uint, bool> = HashMap::new();
3219 let mut mem_buf = MemWriter::new();
3221 let mut encoder = Encoder::new(&mut mem_buf as &mut io::Writer);
3222 hm.encode(&mut encoder).unwrap();
3224 let bytes = mem_buf.unwrap();
3225 let json_str = from_utf8(bytes.as_slice()).unwrap();
3226 match from_str(json_str) {
3227 Err(_) => fail!("Unable to parse json_str: {}", json_str),
3228 _ => {} // it parsed and we are good to go
3233 fn test_prettyencode_hashmap_with_numeric_key() {
3234 use std::str::from_utf8;
3235 use std::io::Writer;
3236 use std::io::MemWriter;
3237 use std::collections::HashMap;
3238 let mut hm: HashMap<uint, bool> = HashMap::new();
3240 let mut mem_buf = MemWriter::new();
3242 let mut encoder = PrettyEncoder::new(&mut mem_buf as &mut io::Writer);
3243 hm.encode(&mut encoder).unwrap()
3245 let bytes = mem_buf.unwrap();
3246 let json_str = from_utf8(bytes.as_slice()).unwrap();
3247 match from_str(json_str) {
3248 Err(_) => fail!("Unable to parse json_str: {}", json_str),
3249 _ => {} // it parsed and we are good to go
3254 fn test_prettyencoder_indent_level_param() {
3255 use std::str::from_utf8;
3256 use std::io::MemWriter;
3257 use std::collections::TreeMap;
3259 let mut tree = TreeMap::new();
3261 tree.insert("hello".into_string(), String("guten tag".into_string()));
3262 tree.insert("goodbye".into_string(), String("sayonara".into_string()));
3265 // The following layout below should look a lot like
3266 // the pretty-printed JSON (indent * x)
3269 String("greetings".into_string()), // 1x
3270 Object(tree), // 1x + 2x + 2x + 1x
3272 // End JSON list (7 lines)
3275 // Helper function for counting indents
3276 fn indents(source: &str) -> uint {
3277 let trimmed = source.trim_left_chars(' ');
3278 source.len() - trimmed.len()
3281 // Test up to 4 spaces of indents (more?)
3282 for i in range(0, 4u) {
3283 let mut writer = MemWriter::new();
3285 let ref mut encoder = PrettyEncoder::new(&mut writer);
3286 encoder.set_indent(i);
3287 json.encode(encoder).unwrap();
3290 let bytes = writer.unwrap();
3291 let printed = from_utf8(bytes.as_slice()).unwrap();
3293 // Check for indents at each line
3294 let lines: Vec<&str> = printed.lines().collect();
3295 assert_eq!(lines.len(), 7); // JSON should be 7 lines
3297 assert_eq!(indents(lines[0]), 0 * i); // [
3298 assert_eq!(indents(lines[1]), 1 * i); // "greetings",
3299 assert_eq!(indents(lines[2]), 1 * i); // {
3300 assert_eq!(indents(lines[3]), 2 * i); // "hello": "guten tag",
3301 assert_eq!(indents(lines[4]), 2 * i); // "goodbye": "sayonara"
3302 assert_eq!(indents(lines[5]), 1 * i); // },
3303 assert_eq!(indents(lines[6]), 0 * i); // ]
3305 // Finally, test that the pretty-printed JSON is valid
3306 from_str(printed).ok().expect("Pretty-printed JSON is invalid!");
3311 fn test_hashmap_with_numeric_key_can_handle_double_quote_delimited_key() {
3312 use std::collections::HashMap;
3314 let json_str = "{\"1\":true}";
3315 let json_obj = match from_str(json_str) {
3316 Err(_) => fail!("Unable to parse json_str: {}", json_str),
3319 let mut decoder = Decoder::new(json_obj);
3320 let _hm: HashMap<uint, bool> = Decodable::decode(&mut decoder).unwrap();
3324 fn test_hashmap_with_numeric_key_will_error_with_string_keys() {
3325 use std::collections::HashMap;
3327 let json_str = "{\"a\":true}";
3328 let json_obj = match from_str(json_str) {
3329 Err(_) => fail!("Unable to parse json_str: {}", json_str),
3332 let mut decoder = Decoder::new(json_obj);
3333 let result: Result<HashMap<uint, bool>, DecoderError> = Decodable::decode(&mut decoder);
3334 assert_eq!(result, Err(ExpectedError("Number".to_string(), "a".to_string())));
3337 fn assert_stream_equal(src: &str,
3338 expected: Vec<(JsonEvent, Vec<StackElement>)>) {
3339 let mut parser = Parser::new(src.chars());
3342 let evt = match parser.next() {
3346 let (ref expected_evt, ref expected_stack) = expected[i];
3347 if !parser.stack().is_equal_to(expected_stack.as_slice()) {
3348 fail!("Parser stack is not equal to {}", expected_stack);
3350 assert_eq!(&evt, expected_evt);
3355 #[ignore(cfg(target_word_size = "32"))] // FIXME(#14064)
3356 fn test_streaming_parser() {
3357 assert_stream_equal(
3358 r#"{ "foo":"bar", "array" : [0, 1, 2, 3, 4, 5], "idents":[null,true,false]}"#,
3360 (ObjectStart, vec![]),
3361 (StringValue("bar".to_string()), vec![Key("foo")]),
3362 (ListStart, vec![Key("array")]),
3363 (U64Value(0), vec![Key("array"), Index(0)]),
3364 (U64Value(1), vec![Key("array"), Index(1)]),
3365 (U64Value(2), vec![Key("array"), Index(2)]),
3366 (U64Value(3), vec![Key("array"), Index(3)]),
3367 (U64Value(4), vec![Key("array"), Index(4)]),
3368 (U64Value(5), vec![Key("array"), Index(5)]),
3369 (ListEnd, vec![Key("array")]),
3370 (ListStart, vec![Key("idents")]),
3371 (NullValue, vec![Key("idents"), Index(0)]),
3372 (BooleanValue(true), vec![Key("idents"), Index(1)]),
3373 (BooleanValue(false), vec![Key("idents"), Index(2)]),
3374 (ListEnd, vec![Key("idents")]),
3375 (ObjectEnd, vec![]),
3379 fn last_event(src: &str) -> JsonEvent {
3380 let mut parser = Parser::new(src.chars());
3381 let mut evt = NullValue;
3383 evt = match parser.next() {
3391 #[ignore(cfg(target_word_size = "32"))] // FIXME(#14064)
3392 fn test_read_object_streaming() {
3393 assert_eq!(last_event("{ "), Error(SyntaxError(EOFWhileParsingObject, 1, 3)));
3394 assert_eq!(last_event("{1"), Error(SyntaxError(KeyMustBeAString, 1, 2)));
3395 assert_eq!(last_event("{ \"a\""), Error(SyntaxError(EOFWhileParsingObject, 1, 6)));
3396 assert_eq!(last_event("{\"a\""), Error(SyntaxError(EOFWhileParsingObject, 1, 5)));
3397 assert_eq!(last_event("{\"a\" "), Error(SyntaxError(EOFWhileParsingObject, 1, 6)));
3399 assert_eq!(last_event("{\"a\" 1"), Error(SyntaxError(ExpectedColon, 1, 6)));
3400 assert_eq!(last_event("{\"a\":"), Error(SyntaxError(EOFWhileParsingValue, 1, 6)));
3401 assert_eq!(last_event("{\"a\":1"), Error(SyntaxError(EOFWhileParsingObject, 1, 7)));
3402 assert_eq!(last_event("{\"a\":1 1"), Error(SyntaxError(InvalidSyntax, 1, 8)));
3403 assert_eq!(last_event("{\"a\":1,"), Error(SyntaxError(EOFWhileParsingObject, 1, 8)));
3404 assert_eq!(last_event("{\"a\":1,}"), Error(SyntaxError(TrailingComma, 1, 8)));
3406 assert_stream_equal(
3408 vec![(ObjectStart, vec![]), (ObjectEnd, vec![])]
3410 assert_stream_equal(
3413 (ObjectStart, vec![]),
3414 (U64Value(3), vec![Key("a")]),
3415 (ObjectEnd, vec![]),
3418 assert_stream_equal(
3419 "{ \"a\": null, \"b\" : true }",
3421 (ObjectStart, vec![]),
3422 (NullValue, vec![Key("a")]),
3423 (BooleanValue(true), vec![Key("b")]),
3424 (ObjectEnd, vec![]),
3427 assert_stream_equal(
3428 "{\"a\" : 1.0 ,\"b\": [ true ]}",
3430 (ObjectStart, vec![]),
3431 (F64Value(1.0), vec![Key("a")]),
3432 (ListStart, vec![Key("b")]),
3433 (BooleanValue(true),vec![Key("b"), Index(0)]),
3434 (ListEnd, vec![Key("b")]),
3435 (ObjectEnd, vec![]),
3438 assert_stream_equal(
3444 { "c": {"d": null} }
3448 (ObjectStart, vec![]),
3449 (F64Value(1.0), vec![Key("a")]),
3450 (ListStart, vec![Key("b")]),
3451 (BooleanValue(true), vec![Key("b"), Index(0)]),
3452 (StringValue("foo\nbar".to_string()), vec![Key("b"), Index(1)]),
3453 (ObjectStart, vec![Key("b"), Index(2)]),
3454 (ObjectStart, vec![Key("b"), Index(2), Key("c")]),
3455 (NullValue, vec![Key("b"), Index(2), Key("c"), Key("d")]),
3456 (ObjectEnd, vec![Key("b"), Index(2), Key("c")]),
3457 (ObjectEnd, vec![Key("b"), Index(2)]),
3458 (ListEnd, vec![Key("b")]),
3459 (ObjectEnd, vec![]),
3464 #[ignore(cfg(target_word_size = "32"))] // FIXME(#14064)
3465 fn test_read_list_streaming() {
3466 assert_stream_equal(
3469 (ListStart, vec![]),
3473 assert_stream_equal(
3476 (ListStart, vec![]),
3480 assert_stream_equal(
3483 (ListStart, vec![]),
3484 (BooleanValue(true), vec![Index(0)]),
3488 assert_stream_equal(
3491 (ListStart, vec![]),
3492 (BooleanValue(false), vec![Index(0)]),
3496 assert_stream_equal(
3499 (ListStart, vec![]),
3500 (NullValue, vec![Index(0)]),
3504 assert_stream_equal(
3507 (ListStart, vec![]),
3508 (U64Value(3), vec![Index(0)]),
3509 (U64Value(1), vec![Index(1)]),
3513 assert_stream_equal(
3516 (ListStart, vec![]),
3517 (U64Value(3), vec![Index(0)]),
3518 (U64Value(2), vec![Index(1)]),
3522 assert_stream_equal(
3525 (ListStart, vec![]),
3526 (U64Value(2), vec![Index(0)]),
3527 (ListStart, vec![Index(1)]),
3528 (U64Value(4), vec![Index(1), Index(0)]),
3529 (U64Value(1), vec![Index(1), Index(1)]),
3530 (ListEnd, vec![Index(1)]),
3535 assert_eq!(last_event("["), Error(SyntaxError(EOFWhileParsingValue, 1, 2)));
3537 assert_eq!(from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
3538 assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingList, 1, 3)));
3539 assert_eq!(from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
3540 assert_eq!(from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
3541 assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
3545 fn test_trailing_characters_streaming() {
3546 assert_eq!(last_event("nulla"), Error(SyntaxError(TrailingCharacters, 1, 5)));
3547 assert_eq!(last_event("truea"), Error(SyntaxError(TrailingCharacters, 1, 5)));
3548 assert_eq!(last_event("falsea"), Error(SyntaxError(TrailingCharacters, 1, 6)));
3549 assert_eq!(last_event("1a"), Error(SyntaxError(TrailingCharacters, 1, 2)));
3550 assert_eq!(last_event("[]a"), Error(SyntaxError(TrailingCharacters, 1, 3)));
3551 assert_eq!(last_event("{}a"), Error(SyntaxError(TrailingCharacters, 1, 3)));
3554 fn test_read_identifiers_streaming() {
3555 assert_eq!(Parser::new("null".chars()).next(), Some(NullValue));
3556 assert_eq!(Parser::new("true".chars()).next(), Some(BooleanValue(true)));
3557 assert_eq!(Parser::new("false".chars()).next(), Some(BooleanValue(false)));
3559 assert_eq!(last_event("n"), Error(SyntaxError(InvalidSyntax, 1, 2)));
3560 assert_eq!(last_event("nul"), Error(SyntaxError(InvalidSyntax, 1, 4)));
3561 assert_eq!(last_event("t"), Error(SyntaxError(InvalidSyntax, 1, 2)));
3562 assert_eq!(last_event("truz"), Error(SyntaxError(InvalidSyntax, 1, 4)));
3563 assert_eq!(last_event("f"), Error(SyntaxError(InvalidSyntax, 1, 2)));
3564 assert_eq!(last_event("faz"), Error(SyntaxError(InvalidSyntax, 1, 3)));
3569 let mut stack = Stack::new();
3571 assert!(stack.is_empty());
3572 assert!(stack.len() == 0);
3573 assert!(!stack.last_is_index());
3575 stack.push_index(0);
3578 assert!(stack.len() == 1);
3579 assert!(stack.is_equal_to([Index(1)]));
3580 assert!(stack.starts_with([Index(1)]));
3581 assert!(stack.ends_with([Index(1)]));
3582 assert!(stack.last_is_index());
3583 assert!(stack.get(0) == Index(1));
3585 stack.push_key("foo".to_string());
3587 assert!(stack.len() == 2);
3588 assert!(stack.is_equal_to([Index(1), Key("foo")]));
3589 assert!(stack.starts_with([Index(1), Key("foo")]));
3590 assert!(stack.starts_with([Index(1)]));
3591 assert!(stack.ends_with([Index(1), Key("foo")]));
3592 assert!(stack.ends_with([Key("foo")]));
3593 assert!(!stack.last_is_index());
3594 assert!(stack.get(0) == Index(1));
3595 assert!(stack.get(1) == Key("foo"));
3597 stack.push_key("bar".to_string());
3599 assert!(stack.len() == 3);
3600 assert!(stack.is_equal_to([Index(1), Key("foo"), Key("bar")]));
3601 assert!(stack.starts_with([Index(1)]));
3602 assert!(stack.starts_with([Index(1), Key("foo")]));
3603 assert!(stack.starts_with([Index(1), Key("foo"), Key("bar")]));
3604 assert!(stack.ends_with([Key("bar")]));
3605 assert!(stack.ends_with([Key("foo"), Key("bar")]));
3606 assert!(stack.ends_with([Index(1), Key("foo"), Key("bar")]));
3607 assert!(!stack.last_is_index());
3608 assert!(stack.get(0) == Index(1));
3609 assert!(stack.get(1) == Key("foo"));
3610 assert!(stack.get(2) == Key("bar"));
3614 assert!(stack.len() == 2);
3615 assert!(stack.is_equal_to([Index(1), Key("foo")]));
3616 assert!(stack.starts_with([Index(1), Key("foo")]));
3617 assert!(stack.starts_with([Index(1)]));
3618 assert!(stack.ends_with([Index(1), Key("foo")]));
3619 assert!(stack.ends_with([Key("foo")]));
3620 assert!(!stack.last_is_index());
3621 assert!(stack.get(0) == Index(1));
3622 assert!(stack.get(1) == Key("foo"));
3627 use std::collections::{HashMap,TreeMap};
3630 let list2 = List(vec!(U64(1), U64(2)));
3631 let list3 = List(vec!(U64(1), U64(2), U64(3)));
3633 let mut tree_map = TreeMap::new();
3634 tree_map.insert("a".to_string(), U64(1));
3635 tree_map.insert("b".to_string(), U64(2));
3639 assert_eq!(list2.to_json(), list2);
3640 assert_eq!(object.to_json(), object);
3641 assert_eq!(3_i.to_json(), I64(3));
3642 assert_eq!(4_i8.to_json(), I64(4));
3643 assert_eq!(5_i16.to_json(), I64(5));
3644 assert_eq!(6_i32.to_json(), I64(6));
3645 assert_eq!(7_i64.to_json(), I64(7));
3646 assert_eq!(8_u.to_json(), U64(8));
3647 assert_eq!(9_u8.to_json(), U64(9));
3648 assert_eq!(10_u16.to_json(), U64(10));
3649 assert_eq!(11_u32.to_json(), U64(11));
3650 assert_eq!(12_u64.to_json(), U64(12));
3651 assert_eq!(13.0_f32.to_json(), F64(13.0_f64));
3652 assert_eq!(14.0_f64.to_json(), F64(14.0_f64));
3653 assert_eq!(().to_json(), Null);
3654 assert_eq!(f32::INFINITY.to_json(), Null);
3655 assert_eq!(f64::NAN.to_json(), Null);
3656 assert_eq!(true.to_json(), Boolean(true));
3657 assert_eq!(false.to_json(), Boolean(false));
3658 assert_eq!("abc".to_string().to_json(), String("abc".to_string()));
3659 assert_eq!((1u, 2u).to_json(), list2);
3660 assert_eq!((1u, 2u, 3u).to_json(), list3);
3661 assert_eq!([1u, 2].to_json(), list2);
3662 assert_eq!((&[1u, 2, 3]).to_json(), list3);
3663 assert_eq!((vec![1u, 2]).to_json(), list2);
3664 assert_eq!(vec!(1u, 2, 3).to_json(), list3);
3665 let mut tree_map = TreeMap::new();
3666 tree_map.insert("a".to_string(), 1u);
3667 tree_map.insert("b".to_string(), 2);
3668 assert_eq!(tree_map.to_json(), object);
3669 let mut hash_map = HashMap::new();
3670 hash_map.insert("a".to_string(), 1u);
3671 hash_map.insert("b".to_string(), 2);
3672 assert_eq!(hash_map.to_json(), object);
3673 assert_eq!(Some(15i).to_json(), I64(15));
3674 assert_eq!(Some(15u).to_json(), U64(15));
3675 assert_eq!(None::<int>.to_json(), Null);
3679 fn bench_streaming_small(b: &mut Bencher) {
3681 let mut parser = Parser::new(
3687 { "c": {"d": null} }
3692 match parser.next() {
3700 fn bench_small(b: &mut Bencher) {
3702 let _ = from_str(r#"{
3707 { "c": {"d": null} }
3713 fn big_json() -> string::String {
3714 let mut src = "[\n".to_string();
3715 for _ in range(0i, 500) {
3716 src.push_str(r#"{ "a": true, "b": null, "c":3.1415, "d": "Hello world", "e": \
3719 src.push_str("{}]");
3724 fn bench_streaming_large(b: &mut Bencher) {
3725 let src = big_json();
3727 let mut parser = Parser::new(src.as_slice().chars());
3729 match parser.next() {
3737 fn bench_large(b: &mut Bencher) {
3738 let src = big_json();
3739 b.iter( || { let _ = from_str(src.as_slice()); });