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_docs)]
17 //! JSON parsing and serialization
21 //! JSON (JavaScript Object Notation) is a way to write data in Javascript.
22 //! Like XML, it allows to encode structured data in a text format that can be easily read by humans
23 //! Its simple syntax and native compatibility with JavaScript have made it a widely used format.
25 //! Data types that can be encoded are JavaScript types (see the `Json` enum for more details):
27 //! * `Boolean`: equivalent to rust's `bool`
28 //! * `Number`: equivalent to rust's `f64`
29 //! * `String`: equivalent to rust's `String`
30 //! * `Array`: equivalent to rust's `Vec<T>`, but also allowing objects of different types in the
32 //! * `Object`: equivalent to rust's `BTreeMap<String, json::Json>`
35 //! An object is a series of string keys mapping to values, in `"key": value` format.
36 //! Arrays are enclosed in square brackets ([ ... ]) and objects in curly brackets ({ ... }).
37 //! A simple JSON document encoding a person, their age, address and phone numbers could look like
41 //! "FirstName": "John",
42 //! "LastName": "Doe",
45 //! "Street": "Downing Street 10",
47 //! "Country": "Great Britain"
56 //! # Rust Type-based Encoding and Decoding
58 //! Rust provides a mechanism for low boilerplate encoding & decoding of values to and from JSON via
59 //! the serialization API.
60 //! To be able to encode a piece of data, it must implement the `serialize::RustcEncodable` trait.
61 //! To be able to decode a piece of data, it must implement the `serialize::RustcDecodable` trait.
62 //! The Rust compiler provides an annotation to automatically generate the code for these traits:
63 //! `#[derive(RustcDecodable, RustcEncodable)]`
65 //! The JSON API provides an enum `json::Json` and a trait `ToJson` to encode objects.
66 //! The `ToJson` trait provides a `to_json` method to convert an object into a `json::Json` value.
67 //! A `json::Json` value can be encoded as a string or buffer using the functions described above.
68 //! You can also use the `json::Encoder` object, which implements the `Encoder` trait.
70 //! When using `ToJson` the `RustcEncodable` trait implementation is not mandatory.
74 //! ## Using Autoserialization
76 //! Create a struct called `TestStruct` and serialize and deserialize it to and from JSON using the
77 //! serialization API, using the derived serialization code.
80 //! // FIXME(#19470): this cannot be ```rust``` because it fails orphan checking at the moment
81 //! extern crate serialize;
82 //! use serialize::json;
84 //! // Automatically generate `Decodable` and `Encodable` trait implementations
85 //! #[derive(RustcDecodable, RustcEncodable)]
86 //! pub struct TestStruct {
89 //! data_vector: Vec<u8>,
93 //! let object = TestStruct {
95 //! data_str: "homura".to_string(),
96 //! data_vector: vec![2,3,4,5],
99 //! // Serialize using `json::encode`
100 //! let encoded = json::encode(&object).unwrap();
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
110 //! for custom mappings.
112 //! ### Simple example of `ToJson` usage
115 //! // FIXME(#19470): this cannot be ```rust``` because it fails orphan checking at the moment
116 //! extern crate serialize;
117 //! use serialize::json::{self, ToJson, Json};
119 //! // A custom data structure
120 //! struct ComplexNum {
125 //! // JSON value representation
126 //! impl ToJson for ComplexNum {
127 //! fn to_json(&self) -> Json {
128 //! Json::String(format!("{}+{}i", self.a, self.b))
132 //! // Only generate `RustcEncodable` trait implementation
133 //! #[derive(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(),
145 //! val: num.to_json(),
147 //! println!("data: {}", data);
148 //! // data: {"uid":1,"dsc":"test","val":"0.0001+12.539j"};
152 //! ### Verbose example of `ToJson` usage
155 //! // FIXME(#19470): this cannot be ```rust``` because it fails orphan checking at the moment
156 //! extern crate serialize;
157 //! use std::collections::BTreeMap;
158 //! use serialize::json::{self, Json, ToJson};
160 //! // Only generate `Decodable` trait implementation
161 //! #[derive(Decodable)]
162 //! pub struct TestStruct {
164 //! data_str: String,
165 //! data_vector: Vec<u8>,
168 //! // Specify encoding method manually
169 //! impl ToJson for TestStruct {
170 //! fn to_json(&self) -> Json {
171 //! let mut d = BTreeMap::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: "madoka".to_string(),
185 //! data_vector: vec![2,3,4,5],
187 //! let json_obj: 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();
195 use self::JsonEvent
::*;
196 use self::ErrorCode
::*;
197 use self::ParserError
::*;
198 use self::DecoderError
::*;
199 use self::ParserState
::*;
200 use self::InternalStackElement
::*;
203 use std
::collections
::{HashMap, BTreeMap}
;
204 use std
::{char, f64, fmt, old_io, num, str}
;
205 use std
::mem
::{swap}
;
206 use std
::num
::{Float, Int}
;
207 use std
::num
::FpCategory
as Fp
;
208 use std
::str::FromStr
;
211 use unicode
::str as unicode_str
;
212 use unicode
::str::Utf16Item
;
216 /// Represents a json value
217 #[derive(Clone, PartialEq, PartialOrd, Debug)]
222 String(string
::String
),
225 Object(self::Object
),
229 pub type Array
= Vec
<Json
>;
230 pub type Object
= BTreeMap
<string
::String
, Json
>;
232 pub struct PrettyJson
<'a
> { inner: &'a Json }
234 pub struct AsJson
<'a
, T
: 'a
> { inner: &'a T }
235 pub struct AsPrettyJson
<'a
, T
: 'a
> { inner: &'a T, indent: Option<uint> }
237 /// The errors that can arise while parsing a JSON stream.
238 #[derive(Clone, Copy, PartialEq, Debug)]
242 EOFWhileParsingObject
,
243 EOFWhileParsingArray
,
244 EOFWhileParsingValue
,
245 EOFWhileParsingString
,
251 InvalidUnicodeCodePoint
,
252 LoneLeadingSurrogateInHexEscape
,
253 UnexpectedEndOfHexEscape
,
259 #[derive(Clone, Copy, PartialEq, Debug)]
260 pub enum ParserError
{
262 SyntaxError(ErrorCode
, uint
, uint
),
263 IoError(old_io
::IoErrorKind
, &'
static str),
266 // Builder and Parser have the same errors.
267 pub type BuilderError
= ParserError
;
269 #[derive(Clone, PartialEq, Debug)]
270 pub enum DecoderError
{
271 ParseError(ParserError
),
272 ExpectedError(string
::String
, string
::String
),
273 MissingFieldError(string
::String
),
274 UnknownVariantError(string
::String
),
275 ApplicationError(string
::String
)
278 #[derive(Copy, Debug)]
279 pub enum EncoderError
{
280 FmtError(fmt
::Error
),
284 /// Returns a readable error string for a given error code.
285 pub fn error_str(error
: ErrorCode
) -> &'
static str {
287 InvalidSyntax
=> "invalid syntax",
288 InvalidNumber
=> "invalid number",
289 EOFWhileParsingObject
=> "EOF While parsing object",
290 EOFWhileParsingArray
=> "EOF While parsing array",
291 EOFWhileParsingValue
=> "EOF While parsing value",
292 EOFWhileParsingString
=> "EOF While parsing string",
293 KeyMustBeAString
=> "key must be a string",
294 ExpectedColon
=> "expected `:`",
295 TrailingCharacters
=> "trailing characters",
296 TrailingComma
=> "trailing comma",
297 InvalidEscape
=> "invalid escape",
298 UnrecognizedHex
=> "invalid \\u{ esc}ape (unrecognized hex)",
299 NotFourDigit
=> "invalid \\u{ esc}ape (not four digits)",
300 NotUtf8
=> "contents not utf-8",
301 InvalidUnicodeCodePoint
=> "invalid Unicode code point",
302 LoneLeadingSurrogateInHexEscape
=> "lone leading surrogate in hex escape",
303 UnexpectedEndOfHexEscape
=> "unexpected end of hex escape",
307 /// Shortcut function to decode a JSON `&str` into an object
308 pub fn decode
<T
: ::Decodable
>(s
: &str) -> DecodeResult
<T
> {
309 let json
= match from_str(s
) {
311 Err(e
) => return Err(ParseError(e
))
314 let mut decoder
= Decoder
::new(json
);
315 ::Decodable
::decode(&mut decoder
)
318 /// Shortcut function to encode a `T` into a JSON `String`
319 pub fn encode
<T
: ::Encodable
>(object
: &T
) -> Result
<string
::String
, EncoderError
> {
320 let mut s
= String
::new();
322 let mut encoder
= Encoder
::new(&mut s
);
323 try
!(object
.encode(&mut encoder
));
328 impl fmt
::Display
for ErrorCode
{
329 fn fmt(&self, f
: &mut fmt
::Formatter
) -> fmt
::Result
{
330 error_str(*self).fmt(f
)
334 fn io_error_to_error(io
: old_io
::IoError
) -> ParserError
{
335 IoError(io
.kind
, io
.desc
)
338 impl fmt
::Display
for ParserError
{
339 fn fmt(&self, f
: &mut fmt
::Formatter
) -> fmt
::Result
{
340 // FIXME this should be a nicer error
341 fmt
::Debug
::fmt(self, f
)
345 impl fmt
::Display
for DecoderError
{
346 fn fmt(&self, f
: &mut fmt
::Formatter
) -> fmt
::Result
{
347 // FIXME this should be a nicer error
348 fmt
::Debug
::fmt(self, f
)
352 impl std
::error
::Error
for DecoderError
{
353 fn description(&self) -> &str { "decoder error" }
356 impl fmt
::Display
for EncoderError
{
357 fn fmt(&self, f
: &mut fmt
::Formatter
) -> fmt
::Result
{
358 // FIXME this should be a nicer error
359 fmt
::Debug
::fmt(self, f
)
363 impl std
::error
::Error
for EncoderError
{
364 fn description(&self) -> &str { "encoder error" }
367 impl std
::error
::FromError
<fmt
::Error
> for EncoderError
{
368 fn from_error(err
: fmt
::Error
) -> EncoderError { EncoderError::FmtError(err) }
371 pub type EncodeResult
= Result
<(), EncoderError
>;
372 pub type DecodeResult
<T
> = Result
<T
, DecoderError
>;
374 fn escape_str(wr
: &mut fmt
::Write
, v
: &str) -> EncodeResult
{
375 try
!(wr
.write_str("\""));
379 for (i
, byte
) in v
.bytes().enumerate() {
380 let escaped
= match byte
{
383 b'\x00' => "\\u0000
",
384 b'\x01' => "\\u0001
",
385 b'\x02' => "\\u0002
",
386 b'\x03' => "\\u0003
",
387 b'\x04' => "\\u0004
",
388 b'\x05' => "\\u0005
",
389 b'\x06' => "\\u0006
",
390 b'\x07' => "\\u0007
",
394 b'\x0b' => "\\u000b
",
397 b'\x0e' => "\\u000e
",
398 b'\x0f' => "\\u000f
",
399 b'\x10' => "\\u0010
",
400 b'\x11' => "\\u0011
",
401 b'\x12' => "\\u0012
",
402 b'\x13' => "\\u0013
",
403 b'\x14' => "\\u0014
",
404 b'\x15' => "\\u0015
",
405 b'\x16' => "\\u0016
",
406 b'\x17' => "\\u0017
",
407 b'\x18' => "\\u0018
",
408 b'\x19' => "\\u0019
",
409 b'\x1a' => "\\u001a
",
410 b'\x1b' => "\\u001b
",
411 b'\x1c' => "\\u001c
",
412 b'\x1d' => "\\u001d
",
413 b'\x1e' => "\\u001e
",
414 b'\x1f' => "\\u001f
",
415 b'\x7f' => "\\u007f
",
420 try!(wr.write_str(&v[start..i]));
423 try!(wr.write_str(escaped));
428 if start != v.len() {
429 try!(wr.write_str(&v[start..]));
432 try!(wr.write_str("\""));
436 fn escape_char(writer: &mut fmt::Write, v: char) -> EncodeResult {
437 let mut buf = [0; 4];
438 let n = v.encode_utf8(&mut buf).unwrap();
439 let buf = unsafe { str::from_utf8_unchecked(&buf[..n]) };
440 escape_str(writer, buf)
443 fn spaces(wr: &mut fmt::Write, mut n: uint) -> EncodeResult {
444 const BUF: &'static str = " ";
446 while n >= BUF.len() {
447 try!(wr.write_str(BUF));
452 try!(wr.write_str(&BUF[..n]));
457 fn fmt_number_or_null(v: f64) -> string::String {
459 Fp::Nan | Fp::Infinite => string::String::from_str("null
"),
460 _ if v.fract() != 0f64 => f64::to_str_digits(v, 6),
461 _ => f64::to_str_digits(v, 6) + ".0",
465 /// A structure for implementing serialization to JSON.
466 pub struct Encoder<'a> {
467 writer: &'a mut (fmt::Write+'a),
468 is_emitting_map_key: bool,
471 impl<'a> Encoder<'a> {
472 /// Creates a new JSON encoder whose output will be written to the writer
474 pub fn new(writer: &'a mut fmt::Write) -> Encoder<'a> {
475 Encoder { writer: writer, is_emitting_map_key: false, }
479 macro_rules! emit_enquoted_if_mapkey {
480 ($enc:ident,$e:expr) => {
481 if $enc.is_emitting_map_key {
482 try!(write!($enc.writer, "\"{}
\"", $e));
485 try!(write!($enc.writer, "{}
", $e));
491 impl<'a> ::Encoder for Encoder<'a> {
492 type Error = EncoderError;
494 fn emit_nil(&mut self) -> EncodeResult {
495 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
496 try!(write!(self.writer, "null
"));
500 fn emit_uint(&mut self, v: uint) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
501 fn emit_u64(&mut self, v: u64) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
502 fn emit_u32(&mut self, v: u32) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
503 fn emit_u16(&mut self, v: u16) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
504 fn emit_u8(&mut self, v: u8) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
506 fn emit_int(&mut self, v: int) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
507 fn emit_i64(&mut self, v: i64) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
508 fn emit_i32(&mut self, v: i32) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
509 fn emit_i16(&mut self, v: i16) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
510 fn emit_i8(&mut self, v: i8) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
512 fn emit_bool(&mut self, v: bool) -> EncodeResult {
513 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
515 try!(write!(self.writer, "true"));
517 try!(write!(self.writer, "false"));
522 fn emit_f64(&mut self, v: f64) -> EncodeResult {
523 emit_enquoted_if_mapkey!(self, fmt_number_or_null(v))
525 fn emit_f32(&mut self, v: f32) -> EncodeResult {
526 self.emit_f64(v as f64)
529 fn emit_char(&mut self, v: char) -> EncodeResult {
530 escape_char(self.writer, v)
532 fn emit_str(&mut self, v: &str) -> EncodeResult {
533 escape_str(self.writer, v)
536 fn emit_enum<F>(&mut self, _name: &str, f: F) -> EncodeResult where
537 F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
542 fn emit_enum_variant<F>(&mut self,
546 f: F) -> EncodeResult where
547 F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
549 // enums are encoded as strings or objects
551 // Kangaroo(34,"William
") => {"variant": "Kangaroo", "fields": [34,"William"]}
553 escape_str(self.writer, name)
555 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
556 try!(write!(self.writer, "{{\"variant
\":"));
557 try!(escape_str(self.writer, name));
558 try!(write!(self.writer, ",\"fields
\":["));
560 try!(write!(self.writer, "]}}"));
565 fn emit_enum_variant_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
566 F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
568 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
570 try!(write!(self.writer, ","));
575 fn emit_enum_struct_variant<F>(&mut self,
579 f: F) -> EncodeResult where
580 F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
582 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
583 self.emit_enum_variant(name, id, cnt, f)
586 fn emit_enum_struct_variant_field<F>(&mut self,
589 f: F) -> EncodeResult where
590 F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
592 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
593 self.emit_enum_variant_arg(idx, f)
596 fn emit_struct<F>(&mut self, _: &str, _: uint, f: F) -> EncodeResult where
597 F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
599 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
600 try!(write!(self.writer, "{{"));
602 try!(write!(self.writer, "}}"));
606 fn emit_struct_field<F>(&mut self, name: &str, idx: uint, f: F) -> EncodeResult where
607 F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
609 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
610 if idx != 0 { try!(write!(self.writer, ",")); }
611 try!(escape_str(self.writer, name));
612 try!(write!(self.writer, ":"));
616 fn emit_tuple<F>(&mut self, len: uint, f: F) -> EncodeResult where
617 F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
619 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
620 self.emit_seq(len, f)
622 fn emit_tuple_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
623 F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
625 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
626 self.emit_seq_elt(idx, f)
629 fn emit_tuple_struct<F>(&mut self, _name: &str, len: uint, f: F) -> EncodeResult where
630 F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
632 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
633 self.emit_seq(len, f)
635 fn emit_tuple_struct_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
636 F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
638 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
639 self.emit_seq_elt(idx, f)
642 fn emit_option<F>(&mut self, f: F) -> EncodeResult where
643 F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
645 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
648 fn emit_option_none(&mut self) -> EncodeResult {
649 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
652 fn emit_option_some<F>(&mut self, f: F) -> EncodeResult where
653 F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
655 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
659 fn emit_seq<F>(&mut self, _len: uint, f: F) -> EncodeResult where
660 F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
662 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
663 try!(write!(self.writer, "["));
665 try!(write!(self.writer, "]"));
669 fn emit_seq_elt<F>(&mut self, idx: uint, f: F) -> EncodeResult where
670 F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
672 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
674 try!(write!(self.writer, ","));
679 fn emit_map<F>(&mut self, _len: uint, f: F) -> EncodeResult where
680 F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
682 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
683 try!(write!(self.writer, "{{"));
685 try!(write!(self.writer, "}}"));
689 fn emit_map_elt_key<F>(&mut self, idx: uint, f: F) -> EncodeResult where
690 F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
692 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
693 if idx != 0 { try!(write!(self.writer, ",")) }
694 self.is_emitting_map_key = true;
696 self.is_emitting_map_key = false;
700 fn emit_map_elt_val<F>(&mut self, _idx: uint, f: F) -> EncodeResult where
701 F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
703 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
704 try!(write!(self.writer, ":"));
709 /// Another encoder for JSON, but prints out human-readable JSON instead of
711 pub struct PrettyEncoder<'a> {
712 writer: &'a mut (fmt::Write+'a),
715 is_emitting_map_key: bool,
718 impl<'a> PrettyEncoder<'a> {
719 /// Creates a new encoder whose output will be written to the specified writer
720 pub fn new(writer: &'a mut fmt::Write) -> PrettyEncoder<'a> {
725 is_emitting_map_key: false,
729 /// Set the number of spaces to indent for each level.
730 /// This is safe to set during encoding.
731 pub fn set_indent(&mut self, indent: uint) {
732 // self.indent very well could be 0 so we need to use checked division.
733 let level = self.curr_indent.checked_div(self.indent).unwrap_or(0);
734 self.indent = indent;
735 self.curr_indent = level * self.indent;
739 impl<'a> ::Encoder for PrettyEncoder<'a> {
740 type Error = EncoderError;
742 fn emit_nil(&mut self) -> EncodeResult {
743 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
744 try!(write!(self.writer, "null
"));
748 fn emit_uint(&mut self, v: uint) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
749 fn emit_u64(&mut self, v: u64) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
750 fn emit_u32(&mut self, v: u32) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
751 fn emit_u16(&mut self, v: u16) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
752 fn emit_u8(&mut self, v: u8) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
754 fn emit_int(&mut self, v: int) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
755 fn emit_i64(&mut self, v: i64) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
756 fn emit_i32(&mut self, v: i32) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
757 fn emit_i16(&mut self, v: i16) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
758 fn emit_i8(&mut self, v: i8) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
760 fn emit_bool(&mut self, v: bool) -> EncodeResult {
761 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
763 try!(write!(self.writer, "true"));
765 try!(write!(self.writer, "false"));
770 fn emit_f64(&mut self, v: f64) -> EncodeResult {
771 emit_enquoted_if_mapkey!(self, fmt_number_or_null(v))
773 fn emit_f32(&mut self, v: f32) -> EncodeResult {
774 self.emit_f64(v as f64)
777 fn emit_char(&mut self, v: char) -> EncodeResult {
778 escape_char(self.writer, v)
780 fn emit_str(&mut self, v: &str) -> EncodeResult {
781 escape_str(self.writer, v)
784 fn emit_enum<F>(&mut self, _name: &str, f: F) -> EncodeResult where
785 F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
790 fn emit_enum_variant<F>(&mut self,
795 -> EncodeResult where
796 F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
799 escape_str(self.writer, name)
801 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
802 try!(write!(self.writer, "{{\n"));
803 self.curr_indent += self.indent;
804 try!(spaces(self.writer, self.curr_indent));
805 try!(write!(self.writer, "\"variant
\": "));
806 try!(escape_str(self.writer, name));
807 try!(write!(self.writer, ",\n"));
808 try!(spaces(self.writer, self.curr_indent));
809 try!(write!(self.writer, "\"fields
\": [\n"));
810 self.curr_indent += self.indent;
812 self.curr_indent -= self.indent;
813 try!(write!(self.writer, "\n"));
814 try!(spaces(self.writer, self.curr_indent));
815 self.curr_indent -= self.indent;
816 try!(write!(self.writer, "]\n"));
817 try!(spaces(self.writer, self.curr_indent));
818 try!(write!(self.writer, "}}"));
823 fn emit_enum_variant_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
824 F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
826 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
828 try!(write!(self.writer, ",\n"));
830 try!(spaces(self.writer, self.curr_indent));
834 fn emit_enum_struct_variant<F>(&mut self,
838 f: F) -> EncodeResult where
839 F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
841 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
842 self.emit_enum_variant(name, id, cnt, f)
845 fn emit_enum_struct_variant_field<F>(&mut self,
848 f: F) -> EncodeResult where
849 F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
851 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
852 self.emit_enum_variant_arg(idx, f)
856 fn emit_struct<F>(&mut self, _: &str, len: uint, f: F) -> EncodeResult where
857 F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
859 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
861 try!(write!(self.writer, "{{}
}"));
863 try!(write!(self.writer, "{{"));
864 self.curr_indent += self.indent;
866 self.curr_indent -= self.indent;
867 try!(write!(self.writer, "\n"));
868 try!(spaces(self.writer, self.curr_indent));
869 try!(write!(self.writer, "}}"));
874 fn emit_struct_field<F>(&mut self, name: &str, idx: uint, f: F) -> EncodeResult where
875 F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
877 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
879 try!(write!(self.writer, "\n"));
881 try!(write!(self.writer, ",\n"));
883 try!(spaces(self.writer, self.curr_indent));
884 try!(escape_str(self.writer, name));
885 try!(write!(self.writer, ": "));
889 fn emit_tuple<F>(&mut self, len: uint, f: F) -> EncodeResult where
890 F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
892 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
893 self.emit_seq(len, f)
895 fn emit_tuple_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
896 F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
898 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
899 self.emit_seq_elt(idx, f)
902 fn emit_tuple_struct<F>(&mut self, _: &str, len: uint, f: F) -> EncodeResult where
903 F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
905 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
906 self.emit_seq(len, f)
908 fn emit_tuple_struct_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
909 F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
911 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
912 self.emit_seq_elt(idx, f)
915 fn emit_option<F>(&mut self, f: F) -> EncodeResult where
916 F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
918 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
921 fn emit_option_none(&mut self) -> EncodeResult {
922 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
925 fn emit_option_some<F>(&mut self, f: F) -> EncodeResult where
926 F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
928 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
932 fn emit_seq<F>(&mut self, len: uint, f: F) -> EncodeResult where
933 F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
935 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
937 try!(write!(self.writer, "[]"));
939 try!(write!(self.writer, "["));
940 self.curr_indent += self.indent;
942 self.curr_indent -= self.indent;
943 try!(write!(self.writer, "\n"));
944 try!(spaces(self.writer, self.curr_indent));
945 try!(write!(self.writer, "]"));
950 fn emit_seq_elt<F>(&mut self, idx: uint, f: F) -> EncodeResult where
951 F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
953 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
955 try!(write!(self.writer, "\n"));
957 try!(write!(self.writer, ",\n"));
959 try!(spaces(self.writer, self.curr_indent));
963 fn emit_map<F>(&mut self, len: uint, f: F) -> EncodeResult where
964 F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
966 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
968 try!(write!(self.writer, "{{}
}"));
970 try!(write!(self.writer, "{{"));
971 self.curr_indent += self.indent;
973 self.curr_indent -= self.indent;
974 try!(write!(self.writer, "\n"));
975 try!(spaces(self.writer, self.curr_indent));
976 try!(write!(self.writer, "}}"));
981 fn emit_map_elt_key<F>(&mut self, idx: uint, f: F) -> EncodeResult where
982 F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
984 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
986 try!(write!(self.writer, "\n"));
988 try!(write!(self.writer, ",\n"));
990 try!(spaces(self.writer, self.curr_indent));
991 self.is_emitting_map_key = true;
993 self.is_emitting_map_key = false;
997 fn emit_map_elt_val<F>(&mut self, _idx: uint, f: F) -> EncodeResult where
998 F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
1000 if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
1001 try!(write!(self.writer, ": "));
1006 impl Encodable for Json {
1007 fn encode<E: ::Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
1009 Json::I64(v) => v.encode(e),
1010 Json::U64(v) => v.encode(e),
1011 Json::F64(v) => v.encode(e),
1012 Json::String(ref v) => v.encode(e),
1013 Json::Boolean(v) => v.encode(e),
1014 Json::Array(ref v) => v.encode(e),
1015 Json::Object(ref v) => v.encode(e),
1016 Json::Null => e.emit_nil(),
1021 /// Create an `AsJson` wrapper which can be used to print a value as JSON
1022 /// on-the-fly via `write!`
1023 pub fn as_json<T>(t: &T) -> AsJson<T> {
1027 /// Create an `AsPrettyJson` wrapper which can be used to print a value as JSON
1028 /// on-the-fly via `write!`
1029 pub fn as_pretty_json<T>(t: &T) -> AsPrettyJson<T> {
1030 AsPrettyJson { inner: t, indent: None }
1034 /// Borrow this json object as a pretty object to generate a pretty
1035 /// representation for it via `Display`.
1036 pub fn pretty(&self) -> PrettyJson {
1037 PrettyJson { inner: self }
1040 /// If the Json value is an Object, returns the value associated with the provided key.
1041 /// Otherwise, returns None.
1042 pub fn find<'a>(&'a self, key: &str) -> Option<&'a Json>{
1044 &Json::Object(ref map) => map.get(key),
1049 /// Attempts to get a nested Json Object for each key in `keys`.
1050 /// If any key is found not to exist, find_path will return None.
1051 /// Otherwise, it will return the Json value associated with the final key.
1052 pub fn find_path<'a>(&'a self, keys: &[&str]) -> Option<&'a Json>{
1053 let mut target = self;
1055 match target.find(*key) {
1056 Some(t) => { target = t; },
1063 /// If the Json value is an Object, performs a depth-first search until
1064 /// a value associated with the provided key is found. If no value is found
1065 /// or the Json value is not an Object, returns None.
1066 pub fn search<'a>(&'a self, key: &str) -> Option<&'a Json> {
1068 &Json::Object(ref map) => {
1069 match map.get(key) {
1070 Some(json_value) => Some(json_value),
1073 match v.search(key) {
1074 x if x.is_some() => return x,
1086 /// Returns true if the Json value is an Object. Returns false otherwise.
1087 pub fn is_object<'a>(&'a self) -> bool {
1088 self.as_object().is_some()
1091 /// If the Json value is an Object, returns the associated BTreeMap.
1092 /// Returns None otherwise.
1093 pub fn as_object<'a>(&'a self) -> Option<&'a Object> {
1095 &Json::Object(ref map) => Some(map),
1100 /// Returns true if the Json value is an Array. Returns false otherwise.
1101 pub fn is_array<'a>(&'a self) -> bool {
1102 self.as_array().is_some()
1105 /// If the Json value is an Array, returns the associated vector.
1106 /// Returns None otherwise.
1107 pub fn as_array<'a>(&'a self) -> Option<&'a Array> {
1109 &Json::Array(ref array) => Some(&*array),
1114 /// Returns true if the Json value is a String. Returns false otherwise.
1115 pub fn is_string<'a>(&'a self) -> bool {
1116 self.as_string().is_some()
1119 /// If the Json value is a String, returns the associated str.
1120 /// Returns None otherwise.
1121 pub fn as_string<'a>(&'a self) -> Option<&'a str> {
1123 Json::String(ref s) => Some(&s[..]),
1128 /// Returns true if the Json value is a Number. Returns false otherwise.
1129 pub fn is_number(&self) -> bool {
1131 Json::I64(_) | Json::U64(_) | Json::F64(_) => true,
1136 /// Returns true if the Json value is a i64. Returns false otherwise.
1137 pub fn is_i64(&self) -> bool {
1139 Json::I64(_) => true,
1144 /// Returns true if the Json value is a u64. Returns false otherwise.
1145 pub fn is_u64(&self) -> bool {
1147 Json::U64(_) => true,
1152 /// Returns true if the Json value is a f64. Returns false otherwise.
1153 pub fn is_f64(&self) -> bool {
1155 Json::F64(_) => true,
1160 /// If the Json value is a number, return or cast it to a i64.
1161 /// Returns None otherwise.
1162 pub fn as_i64(&self) -> Option<i64> {
1164 Json::I64(n) => Some(n),
1165 Json::U64(n) => num::cast(n),
1170 /// If the Json value is a number, return or cast it to a u64.
1171 /// Returns None otherwise.
1172 pub fn as_u64(&self) -> Option<u64> {
1174 Json::I64(n) => num::cast(n),
1175 Json::U64(n) => Some(n),
1180 /// If the Json value is a number, return or cast it to a f64.
1181 /// Returns None otherwise.
1182 pub fn as_f64(&self) -> Option<f64> {
1184 Json::I64(n) => num::cast(n),
1185 Json::U64(n) => num::cast(n),
1186 Json::F64(n) => Some(n),
1191 /// Returns true if the Json value is a Boolean. Returns false otherwise.
1192 pub fn is_boolean(&self) -> bool {
1193 self.as_boolean().is_some()
1196 /// If the Json value is a Boolean, returns the associated bool.
1197 /// Returns None otherwise.
1198 pub fn as_boolean(&self) -> Option<bool> {
1200 &Json::Boolean(b) => Some(b),
1205 /// Returns true if the Json value is a Null. Returns false otherwise.
1206 pub fn is_null(&self) -> bool {
1207 self.as_null().is_some()
1210 /// If the Json value is a Null, returns ().
1211 /// Returns None otherwise.
1212 pub fn as_null(&self) -> Option<()> {
1214 &Json::Null => Some(()),
1220 impl<'a> Index<&'a str> for Json {
1223 fn index(&self, idx: & &str) -> &Json {
1224 self.find(*idx).unwrap()
1228 impl Index<uint> for Json {
1231 fn index<'a>(&'a self, idx: &uint) -> &'a Json {
1233 &Json::Array(ref v) => &v[*idx],
1234 _ => panic!("can only index Json with uint
if it is an array
")
1239 /// The output of the streaming parser.
1240 #[derive(PartialEq, Clone, Debug)]
1241 pub enum JsonEvent {
1250 StringValue(string::String),
1255 #[derive(PartialEq, Debug)]
1257 // Parse a value in an array, true means first element.
1259 // Parse ',' or ']' after an element in an array.
1261 // Parse a key:value in an object, true means first element.
1263 // Parse ',' or ']' after an element in an object.
1267 // Expecting the stream to end.
1269 // Parsing can't continue.
1273 /// A Stack represents the current position of the parser in the logical
1274 /// structure of the JSON stream.
1275 /// For example foo.bar[3].x
1277 stack: Vec<InternalStackElement>,
1278 str_buffer: Vec<u8>,
1281 /// StackElements compose a Stack.
1282 /// For example, StackElement::Key("foo
"), StackElement::Key("bar
"),
1283 /// StackElement::Index(3) and StackElement::Key("x
") are the
1284 /// StackElements compositing the stack that represents foo.bar[3].x
1285 #[derive(PartialEq, Clone, Debug)]
1286 pub enum StackElement<'l> {
1291 // Internally, Key elements are stored as indices in a buffer to avoid
1292 // allocating a string for every member of an object.
1293 #[derive(PartialEq, Clone, Debug)]
1294 enum InternalStackElement {
1296 InternalKey(u16, u16), // start, size
1300 pub fn new() -> Stack {
1301 Stack { stack: Vec::new(), str_buffer: Vec::new() }
1304 /// Returns The number of elements in the Stack.
1305 pub fn len(&self) -> uint { self.stack.len() }
1307 /// Returns true if the stack is empty.
1308 pub fn is_empty(&self) -> bool { self.stack.is_empty() }
1310 /// Provides access to the StackElement at a given index.
1311 /// lower indices are at the bottom of the stack while higher indices are
1313 pub fn get<'l>(&'l self, idx: uint) -> StackElement<'l> {
1314 match self.stack[idx] {
1315 InternalIndex(i) => StackElement::Index(i),
1316 InternalKey(start, size) => {
1317 StackElement::Key(str::from_utf8(
1318 &self.str_buffer[start as uint .. start as uint + size as uint])
1324 /// Compares this stack with an array of StackElements.
1325 pub fn is_equal_to(&self, rhs: &[StackElement]) -> bool {
1326 if self.stack.len() != rhs.len() { return false; }
1327 for i in 0..rhs.len() {
1328 if self.get(i) != rhs[i] { return false; }
1333 /// Returns true if the bottom-most elements of this stack are the same as
1334 /// the ones passed as parameter.
1335 pub fn starts_with(&self, rhs: &[StackElement]) -> bool {
1336 if self.stack.len() < rhs.len() { return false; }
1337 for i in 0..rhs.len() {
1338 if self.get(i) != rhs[i] { return false; }
1343 /// Returns true if the top-most elements of this stack are the same as
1344 /// the ones passed as parameter.
1345 pub fn ends_with(&self, rhs: &[StackElement]) -> bool {
1346 if self.stack.len() < rhs.len() { return false; }
1347 let offset = self.stack.len() - rhs.len();
1348 for i in 0..rhs.len() {
1349 if self.get(i + offset) != rhs[i] { return false; }
1354 /// Returns the top-most element (if any).
1355 pub fn top<'l>(&'l self) -> Option<StackElement<'l>> {
1356 return match self.stack.last() {
1358 Some(&InternalIndex(i)) => Some(StackElement::Index(i)),
1359 Some(&InternalKey(start, size)) => {
1360 Some(StackElement::Key(str::from_utf8(
1361 &self.str_buffer[start as uint .. (start+size) as uint]
1367 // Used by Parser to insert StackElement::Key elements at the top of the stack.
1368 fn push_key(&mut self, key: string::String) {
1369 self.stack.push(InternalKey(self.str_buffer.len() as u16, key.len() as u16));
1370 for c in key.as_bytes() {
1371 self.str_buffer.push(*c);
1375 // Used by Parser to insert StackElement::Index elements at the top of the stack.
1376 fn push_index(&mut self, index: u32) {
1377 self.stack.push(InternalIndex(index));
1380 // Used by Parser to remove the top-most element of the stack.
1382 assert!(!self.is_empty());
1383 match *self.stack.last().unwrap() {
1384 InternalKey(_, sz) => {
1385 let new_size = self.str_buffer.len() - sz as uint;
1386 self.str_buffer.truncate(new_size);
1388 InternalIndex(_) => {}
1393 // Used by Parser to test whether the top-most element is an index.
1394 fn last_is_index(&self) -> bool {
1395 if self.is_empty() { return false; }
1396 return match *self.stack.last().unwrap() {
1397 InternalIndex(_) => true,
1402 // Used by Parser to increment the index of the top-most element.
1403 fn bump_index(&mut self) {
1404 let len = self.stack.len();
1405 let idx = match *self.stack.last().unwrap() {
1406 InternalIndex(i) => { i + 1 }
1409 self.stack[len - 1] = InternalIndex(idx);
1413 /// A streaming JSON parser implemented as an iterator of JsonEvent, consuming
1414 /// an iterator of char.
1415 pub struct Parser<T> {
1420 // We maintain a stack representing where we are in the logical structure
1421 // of the JSON stream.
1423 // A state machine is kept to make it possible to interrupt and resume parsing.
1427 impl<T: Iterator<Item=char>> Iterator for Parser<T> {
1428 type Item = JsonEvent;
1430 fn next(&mut self) -> Option<JsonEvent> {
1431 if self.state == ParseFinished {
1435 if self.state == ParseBeforeFinish {
1436 self.parse_whitespace();
1437 // Make sure there is no trailing characters.
1439 self.state = ParseFinished;
1442 return Some(self.error_event(TrailingCharacters));
1446 return Some(self.parse());
1450 impl<T: Iterator<Item=char>> Parser<T> {
1451 /// Creates the JSON parser.
1452 pub fn new(rdr: T) -> Parser<T> {
1453 let mut p = Parser {
1458 stack: Stack::new(),
1465 /// Provides access to the current position in the logical structure of the
1467 pub fn stack<'l>(&'l self) -> &'l Stack {
1471 fn eof(&self) -> bool { self.ch.is_none() }
1472 fn ch_or_null(&self) -> char { self.ch.unwrap_or('\x00') }
1473 fn bump(&mut self) {
1474 self.ch = self.rdr.next();
1476 if self.ch_is('\n') {
1484 fn next_char(&mut self) -> Option<char> {
1488 fn ch_is(&self, c: char) -> bool {
1492 fn error<U>(&self, reason: ErrorCode) -> Result<U, ParserError> {
1493 Err(SyntaxError(reason, self.line, self.col))
1496 fn parse_whitespace(&mut self) {
1497 while self.ch_is(' ') ||
1500 self.ch_is('\r') { self.bump(); }
1503 fn parse_number(&mut self) -> JsonEvent {
1504 let mut neg = false;
1506 if self.ch_is('-') {
1511 let res = match self.parse_u64() {
1513 Err(e) => { return Error(e); }
1516 if self.ch_is('.') || self.ch_is('e') || self.ch_is('E') {
1517 let mut res = res as f64;
1519 if self.ch_is('.') {
1520 res = match self.parse_decimal(res) {
1522 Err(e) => { return Error(e); }
1526 if self.ch_is('e') || self.ch_is('E') {
1527 res = match self.parse_exponent(res) {
1529 Err(e) => { return Error(e); }
1540 let res = -(res as i64);
1542 // Make sure we didn't underflow.
1544 Error(SyntaxError(InvalidNumber, self.line, self.col))
1554 fn parse_u64(&mut self) -> Result<u64, ParserError> {
1556 let last_accum = 0; // necessary to detect overflow.
1558 match self.ch_or_null() {
1562 // A leading '0' must be the only digit before the decimal point.
1563 match self.ch_or_null() {
1564 '0' ... '9' => return self.error(InvalidNumber),
1570 match self.ch_or_null() {
1571 c @ '0' ... '9' => {
1573 accum += (c as u64) - ('0' as u64);
1575 // Detect overflow by comparing to the last value.
1576 if accum <= last_accum { return self.error(InvalidNumber); }
1584 _ => return self.error(InvalidNumber),
1590 fn parse_decimal(&mut self, mut res: f64) -> Result<f64, ParserError> {
1593 // Make sure a digit follows the decimal place.
1594 match self.ch_or_null() {
1596 _ => return self.error(InvalidNumber)
1601 match self.ch_or_null() {
1602 c @ '0' ... '9' => {
1604 res += (((c as int) - ('0' as int)) as f64) * dec;
1614 fn parse_exponent(&mut self, mut res: f64) -> Result<f64, ParserError> {
1618 let mut neg_exp = false;
1620 if self.ch_is('+') {
1622 } else if self.ch_is('-') {
1627 // Make sure a digit follows the exponent place.
1628 match self.ch_or_null() {
1630 _ => return self.error(InvalidNumber)
1633 match self.ch_or_null() {
1634 c @ '0' ... '9' => {
1636 exp += (c as uint) - ('0' as uint);
1644 let exp = 10_f64.powi(exp as i32);
1654 fn decode_hex_escape(&mut self) -> Result<u16, ParserError> {
1657 while i < 4 && !self.eof() {
1659 n = match self.ch_or_null() {
1660 c @ '0' ... '9' => n * 16 + ((c as u16) - ('0' as u16)),
1661 'a' | 'A' => n * 16 + 10,
1662 'b' | 'B' => n * 16 + 11,
1663 'c' | 'C' => n * 16 + 12,
1664 'd' | 'D' => n * 16 + 13,
1665 'e' | 'E' => n * 16 + 14,
1666 'f' | 'F' => n * 16 + 15,
1667 _ => return self.error(InvalidEscape)
1673 // Error out if we didn't parse 4 digits.
1675 return self.error(InvalidEscape);
1681 fn parse_str(&mut self) -> Result<string::String, ParserError> {
1682 let mut escape = false;
1683 let mut res = string::String::new();
1688 return self.error(EOFWhileParsingString);
1692 match self.ch_or_null() {
1693 '"'
=> res
.push('
"'),
1694 '\\' => res.push('\\'),
1695 '/' => res.push('/'),
1696 'b' => res.push('\x08'),
1697 'f' => res.push('\x0c'),
1698 'n' => res.push('\n'),
1699 'r' => res.push('\r'),
1700 't' => res.push('\t'),
1701 'u' => match try!(self.decode_hex_escape()) {
1702 0xDC00 ... 0xDFFF => {
1703 return self.error(LoneLeadingSurrogateInHexEscape)
1706 // Non-BMP characters are encoded as a sequence of
1707 // two hex escapes, representing UTF-16 surrogates.
1708 n1 @ 0xD800 ... 0xDBFF => {
1709 match (self.next_char(), self.next_char()) {
1710 (Some('\\'), Some('u')) => (),
1711 _ => return self.error(UnexpectedEndOfHexEscape),
1714 let buf = [n1, try!(self.decode_hex_escape())];
1715 match unicode_str::utf16_items(&buf).next() {
1716 Some(Utf16Item::ScalarValue(c)) => res.push(c),
1717 _ => return self.error(LoneLeadingSurrogateInHexEscape),
1721 n => match char::from_u32(n as u32) {
1722 Some(c) => res.push(c),
1723 None => return self.error(InvalidUnicodeCodePoint),
1726 _ => return self.error(InvalidEscape),
1729 } else if self.ch_is('\\') {
1737 Some(c
) => res
.push(c
),
1738 None
=> unreachable
!()
1744 // Invoked at each iteration, consumes the stream until it has enough
1745 // information to return a JsonEvent.
1746 // Manages an internal state so that parsing can be interrupted and resumed.
1747 // Also keeps track of the position in the logical structure of the json
1748 // stream int the form of a stack that can be queried by the user using the
1750 fn parse(&mut self) -> JsonEvent
{
1752 // The only paths where the loop can spin a new iteration
1753 // are in the cases ParseArrayComma and ParseObjectComma if ','
1754 // is parsed. In these cases the state is set to (respectively)
1755 // ParseArray(false) and ParseObject(false), which always return,
1756 // so there is no risk of getting stuck in an infinite loop.
1757 // All other paths return before the end of the loop's iteration.
1758 self.parse_whitespace();
1762 return self.parse_start();
1764 ParseArray(first
) => {
1765 return self.parse_array(first
);
1767 ParseArrayComma
=> {
1768 match self.parse_array_comma_or_end() {
1769 Some(evt
) => { return evt; }
1773 ParseObject(first
) => {
1774 return self.parse_object(first
);
1776 ParseObjectComma
=> {
1778 if self.ch_is('
,'
) {
1779 self.state
= ParseObject(false);
1782 return self.parse_object_end();
1786 return self.error_event(InvalidSyntax
);
1792 fn parse_start(&mut self) -> JsonEvent
{
1793 let val
= self.parse_value();
1794 self.state
= match val
{
1795 Error(_
) => ParseFinished
,
1796 ArrayStart
=> ParseArray(true),
1797 ObjectStart
=> ParseObject(true),
1798 _
=> ParseBeforeFinish
,
1803 fn parse_array(&mut self, first
: bool
) -> JsonEvent
{
1804 if self.ch_is('
]'
) {
1806 self.error_event(InvalidSyntax
)
1808 self.state
= if self.stack
.is_empty() {
1810 } else if self.stack
.last_is_index() {
1820 self.stack
.push_index(0);
1822 let val
= self.parse_value();
1823 self.state
= match val
{
1824 Error(_
) => ParseFinished
,
1825 ArrayStart
=> ParseArray(true),
1826 ObjectStart
=> ParseObject(true),
1827 _
=> ParseArrayComma
,
1833 fn parse_array_comma_or_end(&mut self) -> Option
<JsonEvent
> {
1834 if self.ch_is('
,'
) {
1835 self.stack
.bump_index();
1836 self.state
= ParseArray(false);
1839 } else if self.ch_is('
]'
) {
1841 self.state
= if self.stack
.is_empty() {
1843 } else if self.stack
.last_is_index() {
1850 } else if self.eof() {
1851 Some(self.error_event(EOFWhileParsingArray
))
1853 Some(self.error_event(InvalidSyntax
))
1857 fn parse_object(&mut self, first
: bool
) -> JsonEvent
{
1858 if self.ch_is('
}'
) {
1860 if self.stack
.is_empty() {
1861 return self.error_event(TrailingComma
);
1866 self.state
= if self.stack
.is_empty() {
1868 } else if self.stack
.last_is_index() {
1877 return self.error_event(EOFWhileParsingObject
);
1879 if !self.ch_is('
"') {
1880 return self.error_event(KeyMustBeAString);
1882 let s = match self.parse_str() {
1885 self.state = ParseFinished;
1889 self.parse_whitespace();
1891 return self.error_event(EOFWhileParsingObject);
1892 } else if self.ch_or_null() != ':' {
1893 return self.error_event(ExpectedColon);
1895 self.stack.push_key(s);
1897 self.parse_whitespace();
1899 let val = self.parse_value();
1901 self.state = match val {
1902 Error(_) => ParseFinished,
1903 ArrayStart => ParseArray(true),
1904 ObjectStart => ParseObject(true),
1905 _ => ParseObjectComma,
1910 fn parse_object_end(&mut self) -> JsonEvent {
1911 if self.ch_is('}') {
1912 self.state = if self.stack.is_empty() {
1914 } else if self.stack.last_is_index() {
1921 } else if self.eof() {
1922 self.error_event(EOFWhileParsingObject)
1924 self.error_event(InvalidSyntax)
1928 fn parse_value(&mut self) -> JsonEvent {
1929 if self.eof() { return self.error_event(EOFWhileParsingValue); }
1930 match self.ch_or_null() {
1931 'n' => { self.parse_ident("ull", NullValue) }
1932 't' => { self.parse_ident("rue", BooleanValue(true)) }
1933 'f' => { self.parse_ident("alse", BooleanValue(false)) }
1934 '0' ... '9' | '-' => self.parse_number(),
1935 '"'
=> match self.parse_str() {
1936 Ok(s
) => StringValue(s
),
1947 _
=> { self.error_event(InvalidSyntax) }
1951 fn parse_ident(&mut self, ident
: &str, value
: JsonEvent
) -> JsonEvent
{
1952 if ident
.chars().all(|c
| Some(c
) == self.next_char()) {
1956 Error(SyntaxError(InvalidSyntax
, self.line
, self.col
))
1960 fn error_event(&mut self, reason
: ErrorCode
) -> JsonEvent
{
1961 self.state
= ParseFinished
;
1962 Error(SyntaxError(reason
, self.line
, self.col
))
1966 /// A Builder consumes a json::Parser to create a generic Json structure.
1967 pub struct Builder
<T
> {
1969 token
: Option
<JsonEvent
>,
1972 impl<T
: Iterator
<Item
=char>> Builder
<T
> {
1973 /// Create a JSON Builder.
1974 pub fn new(src
: T
) -> Builder
<T
> {
1975 Builder { parser: Parser::new(src), token: None, }
1978 // Decode a Json value from a Parser.
1979 pub fn build(&mut self) -> Result
<Json
, BuilderError
> {
1981 let result
= self.build_value();
1985 Some(Error(e
)) => { return Err(e); }
1986 ref tok
=> { panic!("unexpected token {:?}
", tok.clone()); }
1991 fn bump(&mut self) {
1992 self.token = self.parser.next();
1995 fn build_value(&mut self) -> Result<Json, BuilderError> {
1996 return match self.token {
1997 Some(NullValue) => Ok(Json::Null),
1998 Some(I64Value(n)) => Ok(Json::I64(n)),
1999 Some(U64Value(n)) => Ok(Json::U64(n)),
2000 Some(F64Value(n)) => Ok(Json::F64(n)),
2001 Some(BooleanValue(b)) => Ok(Json::Boolean(b)),
2002 Some(StringValue(ref mut s)) => {
2003 let mut temp = string::String::new();
2005 Ok(Json::String(temp))
2007 Some(Error(e)) => Err(e),
2008 Some(ArrayStart) => self.build_array(),
2009 Some(ObjectStart) => self.build_object(),
2010 Some(ObjectEnd) => self.parser.error(InvalidSyntax),
2011 Some(ArrayEnd) => self.parser.error(InvalidSyntax),
2012 None => self.parser.error(EOFWhileParsingValue),
2016 fn build_array(&mut self) -> Result<Json, BuilderError> {
2018 let mut values = Vec::new();
2021 if self.token == Some(ArrayEnd) {
2022 return Ok(Json::Array(values.into_iter().collect()));
2024 match self.build_value() {
2025 Ok(v) => values.push(v),
2026 Err(e) => { return Err(e) }
2032 fn build_object(&mut self) -> Result<Json, BuilderError> {
2035 let mut values = BTreeMap::new();
2039 Some(ObjectEnd) => { return Ok(Json::Object(values)); }
2040 Some(Error(e)) => { return Err(e); }
2044 let key = match self.parser.stack().top() {
2045 Some(StackElement::Key(k)) => { k.to_string() }
2046 _ => { panic!("invalid state"); }
2048 match self.build_value() {
2049 Ok(value) => { values.insert(key, value); }
2050 Err(e) => { return Err(e); }
2054 return self.parser.error(EOFWhileParsingObject);
2058 /// Decodes a json value from an `&mut old_io::Reader`
2059 pub fn from_reader(rdr: &mut old_io::Reader) -> Result<Json, BuilderError> {
2060 let contents = match rdr.read_to_end() {
2062 Err(e) => return Err(io_error_to_error(e))
2064 let s = match str::from_utf8(&contents).ok() {
2066 _ => return Err(SyntaxError(NotUtf8, 0, 0))
2068 let mut builder = Builder::new(s.chars());
2072 /// Decodes a json value from a string
2073 pub fn from_str(s: &str) -> Result<Json, BuilderError> {
2074 let mut builder = Builder::new(s.chars());
2078 /// A structure to decode JSON to values in rust.
2079 pub struct Decoder {
2084 /// Creates a new decoder instance for decoding the specified JSON value.
2085 pub fn new(json: Json) -> Decoder {
2086 Decoder { stack: vec![json] }
2091 fn pop(&mut self) -> Json {
2092 self.stack.pop().unwrap()
2096 macro_rules! expect {
2097 ($e:expr, Null) => ({
2099 Json::Null => Ok(()),
2100 other => Err(ExpectedError("Null
".to_string(),
2101 format!("{}
", other)))
2104 ($e:expr, $t:ident) => ({
2106 Json::$t(v) => Ok(v),
2108 Err(ExpectedError(stringify!($t).to_string(),
2109 format!("{}
", other)))
2115 macro_rules! read_primitive {
2116 ($name:ident, $ty:ty) => {
2117 fn $name(&mut self) -> DecodeResult<$ty> {
2119 Json::I64(f) => match num::cast(f) {
2121 None => Err(ExpectedError("Number
".to_string(), format!("{}
", f))),
2123 Json::U64(f) => match num::cast(f) {
2125 None => Err(ExpectedError("Number
".to_string(), format!("{}
", f))),
2127 Json::F64(f) => Err(ExpectedError("Integer
".to_string(), format!("{}
", f))),
2128 // re: #12967.. a type w/ numeric keys (ie HashMap<uint, V> etc)
2129 // is going to have a string here, as per JSON spec.
2130 Json::String(s) => match s.parse().ok() {
2132 None => Err(ExpectedError("Number
".to_string(), s)),
2134 value => Err(ExpectedError("Number
".to_string(), format!("{}
", value))),
2140 impl ::Decoder for Decoder {
2141 type Error = DecoderError;
2143 fn read_nil(&mut self) -> DecodeResult<()> {
2144 expect!(self.pop(), Null)
2147 read_primitive! { read_uint, uint }
2148 read_primitive! { read_u8, u8 }
2149 read_primitive! { read_u16, u16 }
2150 read_primitive! { read_u32, u32 }
2151 read_primitive! { read_u64, u64 }
2152 read_primitive! { read_int, int }
2153 read_primitive! { read_i8, i8 }
2154 read_primitive! { read_i16, i16 }
2155 read_primitive! { read_i32, i32 }
2156 read_primitive! { read_i64, i64 }
2158 fn read_f32(&mut self) -> DecodeResult<f32> { self.read_f64().map(|x| x as f32) }
2160 fn read_f64(&mut self) -> DecodeResult<f64> {
2162 Json::I64(f) => Ok(f as f64),
2163 Json::U64(f) => Ok(f as f64),
2164 Json::F64(f) => Ok(f),
2165 Json::String(s) => {
2166 // re: #12967.. a type w/ numeric keys (ie HashMap<uint, V> etc)
2167 // is going to have a string here, as per JSON spec.
2168 match s.parse().ok() {
2170 None => Err(ExpectedError("Number
".to_string(), s)),
2173 Json::Null => Ok(f64::NAN),
2174 value => Err(ExpectedError("Number
".to_string(), format!("{}
", value)))
2178 fn read_bool(&mut self) -> DecodeResult<bool> {
2179 expect!(self.pop(), Boolean)
2182 fn read_char(&mut self) -> DecodeResult<char> {
2183 let s = try!(self.read_str());
2185 let mut it = s.chars();
2186 match (it.next(), it.next()) {
2187 // exactly one character
2188 (Some(c), None) => return Ok(c),
2192 Err(ExpectedError("single character string
".to_string(), format!("{}
", s)))
2195 fn read_str(&mut self) -> DecodeResult<string::String> {
2196 expect!(self.pop(), String)
2199 fn read_enum<T, F>(&mut self, _name: &str, f: F) -> DecodeResult<T> where
2200 F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2205 fn read_enum_variant<T, F>(&mut self, names: &[&str],
2206 mut f: F) -> DecodeResult<T>
2207 where F: FnMut(&mut Decoder, uint) -> DecodeResult<T>,
2209 let name = match self.pop() {
2210 Json::String(s) => s,
2211 Json::Object(mut o) => {
2212 let n = match o.remove(&"variant
".to_string()) {
2213 Some(Json::String(s)) => s,
2215 return Err(ExpectedError("String
".to_string(), format!("{}
", val)))
2218 return Err(MissingFieldError("variant
".to_string()))
2221 match o.remove(&"fields
".to_string()) {
2222 Some(Json::Array(l)) => {
2223 for field in l.into_iter().rev() {
2224 self.stack.push(field);
2228 return Err(ExpectedError("Array
".to_string(), format!("{}
", val)))
2231 return Err(MissingFieldError("fields
".to_string()))
2237 return Err(ExpectedError("String or Object
".to_string(), format!("{}
", json)))
2240 let idx = match names.iter().position(|n| *n == &name[..]) {
2242 None => return Err(UnknownVariantError(name))
2247 fn read_enum_variant_arg<T, F>(&mut self, _idx: uint, f: F) -> DecodeResult<T> where
2248 F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2253 fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> DecodeResult<T> where
2254 F: FnMut(&mut Decoder, uint) -> DecodeResult<T>,
2256 self.read_enum_variant(names, f)
2260 fn read_enum_struct_variant_field<T, F>(&mut self,
2264 -> DecodeResult<T> where
2265 F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2267 self.read_enum_variant_arg(idx, f)
2270 fn read_struct<T, F>(&mut self, _name: &str, _len: uint, f: F) -> DecodeResult<T> where
2271 F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2273 let value = try!(f(self));
2278 fn read_struct_field<T, F>(&mut self,
2282 -> DecodeResult<T> where
2283 F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2285 let mut obj = try!(expect!(self.pop(), Object));
2287 let value = match obj.remove(&name.to_string()) {
2289 // Add a Null and try to parse it as an Option<_>
2290 // to get None as a default value.
2291 self.stack.push(Json::Null);
2294 Err(_) => return Err(MissingFieldError(name.to_string())),
2298 self.stack.push(json);
2302 self.stack.push(Json::Object(obj));
2306 fn read_tuple<T, F>(&mut self, tuple_len: uint, f: F) -> DecodeResult<T> where
2307 F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2309 self.read_seq(move |d, len| {
2310 if len == tuple_len {
2313 Err(ExpectedError(format!("Tuple{}
", tuple_len), format!("Tuple{}
", len)))
2318 fn read_tuple_arg<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
2319 F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2321 self.read_seq_elt(idx, f)
2324 fn read_tuple_struct<T, F>(&mut self,
2328 -> DecodeResult<T> where
2329 F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2331 self.read_tuple(len, f)
2334 fn read_tuple_struct_arg<T, F>(&mut self,
2337 -> DecodeResult<T> where
2338 F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2340 self.read_tuple_arg(idx, f)
2343 fn read_option<T, F>(&mut self, mut f: F) -> DecodeResult<T> where
2344 F: FnMut(&mut Decoder, bool) -> DecodeResult<T>,
2347 Json::Null => f(self, false),
2348 value => { self.stack.push(value); f(self, true) }
2352 fn read_seq<T, F>(&mut self, f: F) -> DecodeResult<T> where
2353 F: FnOnce(&mut Decoder, uint) -> DecodeResult<T>,
2355 let array = try!(expect!(self.pop(), Array));
2356 let len = array.len();
2357 for v in array.into_iter().rev() {
2363 fn read_seq_elt<T, F>(&mut self, _idx: uint, f: F) -> DecodeResult<T> where
2364 F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2369 fn read_map<T, F>(&mut self, f: F) -> DecodeResult<T> where
2370 F: FnOnce(&mut Decoder, uint) -> DecodeResult<T>,
2372 let obj = try!(expect!(self.pop(), Object));
2373 let len = obj.len();
2374 for (key, value) in obj {
2375 self.stack.push(value);
2376 self.stack.push(Json::String(key));
2381 fn read_map_elt_key<T, F>(&mut self, _idx: uint, f: F) -> DecodeResult<T> where
2382 F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2387 fn read_map_elt_val<T, F>(&mut self, _idx: uint, f: F) -> DecodeResult<T> where
2388 F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2393 fn error(&mut self, err: &str) -> DecoderError {
2394 ApplicationError(err.to_string())
2398 /// A trait for converting values to JSON
2400 /// Converts the value of `self` to an instance of JSON
2401 fn to_json(&self) -> Json;
2404 macro_rules! to_json_impl_i64 {
2406 $(impl ToJson for $t {
2407 fn to_json(&self) -> Json { Json::I64(*self as i64) }
2412 to_json_impl_i64! { int, i8, i16, i32, i64 }
2414 macro_rules! to_json_impl_u64 {
2416 $(impl ToJson for $t {
2417 fn to_json(&self) -> Json { Json::U64(*self as u64) }
2422 to_json_impl_u64! { uint, u8, u16, u32, u64 }
2424 impl ToJson for Json {
2425 fn to_json(&self) -> Json { self.clone() }
2428 impl ToJson for f32 {
2429 fn to_json(&self) -> Json { (*self as f64).to_json() }
2432 impl ToJson for f64 {
2433 fn to_json(&self) -> Json {
2434 match self.classify() {
2435 Fp::Nan | Fp::Infinite => Json::Null,
2436 _ => Json::F64(*self)
2441 impl ToJson for () {
2442 fn to_json(&self) -> Json { Json::Null }
2445 impl ToJson for bool {
2446 fn to_json(&self) -> Json { Json::Boolean(*self) }
2449 impl ToJson for str {
2450 fn to_json(&self) -> Json { Json::String(self.to_string()) }
2453 impl ToJson for string::String {
2454 fn to_json(&self) -> Json { Json::String((*self).clone()) }
2457 macro_rules! tuple_impl {
2458 // use variables to indicate the arity of the tuple
2459 ($($tyvar:ident),* ) => {
2460 // the trailing commas are for the 1 tuple
2462 $( $tyvar : ToJson ),*
2463 > ToJson for ( $( $tyvar ),* , ) {
2466 #[allow(non_snake_case)]
2467 fn to_json(&self) -> Json {
2469 ($(ref $tyvar),*,) => Json::Array(vec![$($tyvar.to_json()),*])
2478 tuple_impl!{A, B, C}
2479 tuple_impl!{A, B, C, D}
2480 tuple_impl!{A, B, C, D, E}
2481 tuple_impl!{A, B, C, D, E, F}
2482 tuple_impl!{A, B, C, D, E, F, G}
2483 tuple_impl!{A, B, C, D, E, F, G, H}
2484 tuple_impl!{A, B, C, D, E, F, G, H, I}
2485 tuple_impl!{A, B, C, D, E, F, G, H, I, J}
2486 tuple_impl!{A, B, C, D, E, F, G, H, I, J, K}
2487 tuple_impl!{A, B, C, D, E, F, G, H, I, J, K, L}
2489 impl<A: ToJson> ToJson for [A] {
2490 fn to_json(&self) -> Json { Json::Array(self.iter().map(|elt| elt.to_json()).collect()) }
2493 impl<A: ToJson> ToJson for Vec<A> {
2494 fn to_json(&self) -> Json { Json::Array(self.iter().map(|elt| elt.to_json()).collect()) }
2497 impl<A: ToJson> ToJson for BTreeMap<string::String, A> {
2498 fn to_json(&self) -> Json {
2499 let mut d = BTreeMap::new();
2500 for (key, value) in self {
2501 d.insert((*key).clone(), value.to_json());
2507 impl<A: ToJson> ToJson for HashMap<string::String, A> {
2508 fn to_json(&self) -> Json {
2509 let mut d = BTreeMap::new();
2510 for (key, value) in self {
2511 d.insert((*key).clone(), value.to_json());
2517 impl<A:ToJson> ToJson for Option<A> {
2518 fn to_json(&self) -> Json {
2521 Some(ref value) => value.to_json()
2526 struct FormatShim<'a, 'b: 'a> {
2527 inner: &'a mut fmt::Formatter<'b>,
2530 impl<'a, 'b> fmt::Write for FormatShim<'a, 'b> {
2531 fn write_str(&mut self, s: &str) -> fmt::Result {
2532 match self.inner.write_str(s) {
2534 Err(_) => Err(fmt::Error)
2539 impl fmt::Display for Json {
2540 /// Encodes a json value into a string
2541 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2542 let mut shim = FormatShim { inner: f };
2543 let mut encoder = Encoder::new(&mut shim);
2544 match self.encode(&mut encoder) {
2546 Err(_) => Err(fmt::Error)
2551 impl<'a> fmt::Display for PrettyJson<'a> {
2552 /// Encodes a json value into a string
2553 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2554 let mut shim = FormatShim { inner: f };
2555 let mut encoder = PrettyEncoder::new(&mut shim);
2556 match self.inner.encode(&mut encoder) {
2558 Err(_) => Err(fmt::Error)
2563 impl<'a, T: Encodable> fmt::Display for AsJson<'a, T> {
2564 /// Encodes a json value into a string
2565 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2566 let mut shim = FormatShim { inner: f };
2567 let mut encoder = Encoder::new(&mut shim);
2568 match self.inner.encode(&mut encoder) {
2570 Err(_) => Err(fmt::Error)
2575 impl<'a, T> AsPrettyJson<'a, T> {
2576 /// Set the indentation level for the emitted JSON
2577 pub fn indent(mut self, indent: uint) -> AsPrettyJson<'a, T> {
2578 self.indent = Some(indent);
2583 impl<'a, T: Encodable> fmt::Display for AsPrettyJson<'a, T> {
2584 /// Encodes a json value into a string
2585 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2586 let mut shim = FormatShim { inner: f };
2587 let mut encoder = PrettyEncoder::new(&mut shim);
2589 Some(n) => encoder.set_indent(n),
2592 match self.inner.encode(&mut encoder) {
2594 Err(_) => Err(fmt::Error)
2599 impl FromStr for Json {
2600 type Err = BuilderError;
2601 fn from_str(s: &str) -> Result<Json, BuilderError> {
2609 use self::Animal::*;
2610 use self::DecodeEnum::*;
2611 use self::test::Bencher;
2612 use {Encodable, Decodable};
2614 use super::ErrorCode::*;
2615 use super::ParserError::*;
2616 use super::DecoderError::*;
2617 use super::JsonEvent::*;
2618 use super::{Json, from_str, DecodeResult, DecoderError, JsonEvent, Parser,
2619 StackElement, Stack, Decoder, Encoder, EncoderError};
2620 use std::{i64, u64, f32, f64};
2621 use std::collections::BTreeMap;
2622 use std::num::Float;
2625 #[derive(RustcDecodable, Eq, PartialEq, Debug)]
2631 fn test_decode_option_none() {
2633 let obj: OptionData = super::decode(s).unwrap();
2634 assert_eq!(obj, OptionData { opt: None });
2638 fn test_decode_option_some() {
2639 let s = "{ \"opt\": 10 }
";
2640 let obj: OptionData = super::decode(s).unwrap();
2641 assert_eq!(obj, OptionData { opt: Some(10) });
2645 fn test_decode_option_malformed() {
2646 check_err::<OptionData>("{ \"opt\": [] }
",
2647 ExpectedError("Number
".to_string(), "[]".to_string()));
2648 check_err::<OptionData>("{ \"opt\": false }
",
2649 ExpectedError("Number
".to_string(), "false".to_string()));
2652 #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
2655 Frog(string::String, int)
2658 #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
2662 c: Vec<string::String>,
2665 #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
2670 fn mk_object(items: &[(string::String, Json)]) -> Json {
2671 let mut d = BTreeMap::new();
2675 (ref key, ref value) => { d.insert((*key).clone(), (*value).clone()); },
2683 fn test_from_str_trait() {
2685 assert!(s.parse::<Json>().unwrap() == s.parse().unwrap());
2689 fn test_write_null() {
2690 assert_eq!(Null.to_string(), "null
");
2691 assert_eq!(Null.pretty().to_string(), "null
");
2695 fn test_write_i64() {
2696 assert_eq!(U64(0).to_string(), "0");
2697 assert_eq!(U64(0).pretty().to_string(), "0");
2699 assert_eq!(U64(1234).to_string(), "1234");
2700 assert_eq!(U64(1234).pretty().to_string(), "1234");
2702 assert_eq!(I64(-5678).to_string(), "-5678");
2703 assert_eq!(I64(-5678).pretty().to_string(), "-5678");
2705 assert_eq!(U64(7650007200025252000).to_string(), "7650007200025252000");
2706 assert_eq!(U64(7650007200025252000).pretty().to_string(), "7650007200025252000");
2710 fn test_write_f64() {
2711 assert_eq!(F64(3.0).to_string(), "3.0");
2712 assert_eq!(F64(3.0).pretty().to_string(), "3.0");
2714 assert_eq!(F64(3.1).to_string(), "3.1");
2715 assert_eq!(F64(3.1).pretty().to_string(), "3.1");
2717 assert_eq!(F64(-1.5).to_string(), "-1.5");
2718 assert_eq!(F64(-1.5).pretty().to_string(), "-1.5");
2720 assert_eq!(F64(0.5).to_string(), "0.5");
2721 assert_eq!(F64(0.5).pretty().to_string(), "0.5");
2723 assert_eq!(F64(f64::NAN).to_string(), "null
");
2724 assert_eq!(F64(f64::NAN).pretty().to_string(), "null
");
2726 assert_eq!(F64(f64::INFINITY).to_string(), "null
");
2727 assert_eq!(F64(f64::INFINITY).pretty().to_string(), "null
");
2729 assert_eq!(F64(f64::NEG_INFINITY).to_string(), "null
");
2730 assert_eq!(F64(f64::NEG_INFINITY).pretty().to_string(), "null
");
2734 fn test_write_str() {
2735 assert_eq!(String("".to_string()).to_string(), "\"\"");
2736 assert_eq!(String("".to_string()).pretty().to_string(), "\"\"");
2738 assert_eq!(String("homura
".to_string()).to_string(), "\"homura
\"");
2739 assert_eq!(String("madoka
".to_string()).pretty().to_string(), "\"madoka
\"");
2743 fn test_write_bool() {
2744 assert_eq!(Boolean(true).to_string(), "true");
2745 assert_eq!(Boolean(true).pretty().to_string(), "true");
2747 assert_eq!(Boolean(false).to_string(), "false");
2748 assert_eq!(Boolean(false).pretty().to_string(), "false");
2752 fn test_write_array() {
2753 assert_eq!(Array(vec![]).to_string(), "[]");
2754 assert_eq!(Array(vec![]).pretty().to_string(), "[]");
2756 assert_eq!(Array(vec![Boolean(true)]).to_string(), "[true]");
2758 Array(vec![Boolean(true)]).pretty().to_string(),
2765 let long_test_array = Array(vec![
2768 Array(vec![String("foo
\nbar
".to_string()), F64(3.5)])]);
2770 assert_eq!(long_test_array.to_string(),
2771 "[false,null
,[\"foo
\\nbar
\",3.5]]");
2773 long_test_array.pretty().to_string(),
2787 fn test_write_object() {
2788 assert_eq!(mk_object(&[]).to_string(), "{}
");
2789 assert_eq!(mk_object(&[]).pretty().to_string(), "{}
");
2793 ("a
".to_string(), Boolean(true))
2798 mk_object(&[("a
".to_string(), Boolean(true))]).pretty().to_string(),
2805 let complex_obj = mk_object(&[
2806 ("b
".to_string(), Array(vec![
2807 mk_object(&[("c
".to_string(), String("\x0c
\r".to_string()))]),
2808 mk_object(&[("d
".to_string(), String("".to_string()))])
2813 complex_obj.to_string(),
2816 {\"c\":\"\\f\\r\"}
,\
2822 complex_obj.pretty().to_string(),
2827 \"c
\": \"\\f
\\r
\"\n \
2836 let a = mk_object(&[
2837 ("a
".to_string(), Boolean(true)),
2838 ("b
".to_string(), Array(vec![
2839 mk_object(&[("c
".to_string(), String("\x0c
\r".to_string()))]),
2840 mk_object(&[("d
".to_string(), String("".to_string()))])
2844 // We can't compare the strings directly because the object fields be
2845 // printed in a different order.
2846 assert_eq!(a.clone(), a.to_string().parse().unwrap());
2847 assert_eq!(a.clone(), a.pretty().to_string().parse().unwrap());
2851 fn test_write_enum() {
2854 format!("{}
", super::as_json(&animal)),
2858 format!("{}
", super::as_pretty_json(&animal)),
2862 let animal = Frog("Henry
".to_string(), 349);
2864 format!("{}
", super::as_json(&animal)),
2865 "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}
"
2868 format!("{}
", super::as_pretty_json(&animal)),
2870 \"variant
\": \"Frog
\",\n \
2879 macro_rules! check_encoder_for_simple {
2880 ($value:expr, $expected:expr) => ({
2881 let s = format!("{}
", super::as_json(&$value));
2882 assert_eq!(s, $expected);
2884 let s = format!("{}
", super::as_pretty_json(&$value));
2885 assert_eq!(s, $expected);
2890 fn test_write_some() {
2891 check_encoder_for_simple!(Some("jodhpurs
".to_string()), "\"jodhpurs
\"");
2895 fn test_write_none() {
2896 check_encoder_for_simple!(None::<string::String>, "null
");
2900 fn test_write_char() {
2901 check_encoder_for_simple!('a', "\"a
\"");
2902 check_encoder_for_simple!('\t', "\"\\t
\"");
2903 check_encoder_for_simple!('\u{0000}', "\"\\u0000
\"");
2904 check_encoder_for_simple!('\u{001b}', "\"\\u001b
\"");
2905 check_encoder_for_simple!('\u{007f}', "\"\\u007f
\"");
2906 check_encoder_for_simple!('\u{00a0}', "\"\u{00a0}\"");
2907 check_encoder_for_simple!('\u{abcd}', "\"\u{abcd}\"");
2908 check_encoder_for_simple!('\u{10ffff}', "\"\u{10ffff}
\"");
2912 fn test_trailing_characters() {
2913 assert_eq!(from_str("nulla
"), Err(SyntaxError(TrailingCharacters, 1, 5)));
2914 assert_eq!(from_str("truea
"), Err(SyntaxError(TrailingCharacters, 1, 5)));
2915 assert_eq!(from_str("falsea
"), Err(SyntaxError(TrailingCharacters, 1, 6)));
2916 assert_eq!(from_str("1a
"), Err(SyntaxError(TrailingCharacters, 1, 2)));
2917 assert_eq!(from_str("[]a
"), Err(SyntaxError(TrailingCharacters, 1, 3)));
2918 assert_eq!(from_str("{}a
"), Err(SyntaxError(TrailingCharacters, 1, 3)));
2922 fn test_read_identifiers() {
2923 assert_eq!(from_str("n
"), Err(SyntaxError(InvalidSyntax, 1, 2)));
2924 assert_eq!(from_str("nul
"), Err(SyntaxError(InvalidSyntax, 1, 4)));
2925 assert_eq!(from_str("t
"), Err(SyntaxError(InvalidSyntax, 1, 2)));
2926 assert_eq!(from_str("truz
"), Err(SyntaxError(InvalidSyntax, 1, 4)));
2927 assert_eq!(from_str("f
"), Err(SyntaxError(InvalidSyntax, 1, 2)));
2928 assert_eq!(from_str("faz
"), Err(SyntaxError(InvalidSyntax, 1, 3)));
2930 assert_eq!(from_str("null
"), Ok(Null));
2931 assert_eq!(from_str("true"), Ok(Boolean(true)));
2932 assert_eq!(from_str("false"), Ok(Boolean(false)));
2933 assert_eq!(from_str(" null
"), Ok(Null));
2934 assert_eq!(from_str(" true "), Ok(Boolean(true)));
2935 assert_eq!(from_str(" false "), Ok(Boolean(false)));
2939 fn test_decode_identifiers() {
2940 let v: () = super::decode("null
").unwrap();
2943 let v: bool = super::decode("true").unwrap();
2944 assert_eq!(v, true);
2946 let v: bool = super::decode("false").unwrap();
2947 assert_eq!(v, false);
2951 fn test_read_number() {
2952 assert_eq!(from_str("+"), Err(SyntaxError(InvalidSyntax, 1, 1)));
2953 assert_eq!(from_str("."), Err(SyntaxError(InvalidSyntax, 1, 1)));
2954 assert_eq!(from_str("NaN
"), Err(SyntaxError(InvalidSyntax, 1, 1)));
2955 assert_eq!(from_str("-"), Err(SyntaxError(InvalidNumber, 1, 2)));
2956 assert_eq!(from_str("00"), Err(SyntaxError(InvalidNumber, 1, 2)));
2957 assert_eq!(from_str("1."), Err(SyntaxError(InvalidNumber, 1, 3)));
2958 assert_eq!(from_str("1e
"), Err(SyntaxError(InvalidNumber, 1, 3)));
2959 assert_eq!(from_str("1e
+"), Err(SyntaxError(InvalidNumber, 1, 4)));
2961 assert_eq!(from_str("18446744073709551616"), Err(SyntaxError(InvalidNumber, 1, 20)));
2962 assert_eq!(from_str("-9223372036854775809"), Err(SyntaxError(InvalidNumber, 1, 21)));
2964 assert_eq!(from_str("3"), Ok(U64(3)));
2965 assert_eq!(from_str("3.1"), Ok(F64(3.1)));
2966 assert_eq!(from_str("-1.2"), Ok(F64(-1.2)));
2967 assert_eq!(from_str("0.4"), Ok(F64(0.4)));
2968 assert_eq!(from_str("0.4e5
"), Ok(F64(0.4e5)));
2969 assert_eq!(from_str("0.4e+15"), Ok(F64(0.4e15)));
2970 assert_eq!(from_str("0.4e-01"), Ok(F64(0.4e-01)));
2971 assert_eq!(from_str(" 3 "), Ok(U64(3)));
2973 assert_eq!(from_str("-9223372036854775808"), Ok(I64(i64::MIN)));
2974 assert_eq!(from_str("9223372036854775807"), Ok(U64(i64::MAX as u64)));
2975 assert_eq!(from_str("18446744073709551615"), Ok(U64(u64::MAX)));
2979 fn test_decode_numbers() {
2980 let v: f64 = super::decode("3").unwrap();
2983 let v: f64 = super::decode("3.1").unwrap();
2986 let v: f64 = super::decode("-1.2").unwrap();
2987 assert_eq!(v, -1.2);
2989 let v: f64 = super::decode("0.4").unwrap();
2992 let v: f64 = super::decode("0.4e5
").unwrap();
2993 assert_eq!(v, 0.4e5);
2995 let v: f64 = super::decode("0.4e15
").unwrap();
2996 assert_eq!(v, 0.4e15);
2998 let v: f64 = super::decode("0.4e-01").unwrap();
2999 assert_eq!(v, 0.4e-01);
3001 let v: u64 = super::decode("0").unwrap();
3004 let v: u64 = super::decode("18446744073709551615").unwrap();
3005 assert_eq!(v, u64::MAX);
3007 let v: i64 = super::decode("-9223372036854775808").unwrap();
3008 assert_eq!(v, i64::MIN);
3010 let v: i64 = super::decode("9223372036854775807").unwrap();
3011 assert_eq!(v, i64::MAX);
3013 let res: DecodeResult<i64> = super::decode("765.25252");
3014 assert_eq!(res, Err(ExpectedError("Integer
".to_string(),
3015 "765.25252".to_string())));
3019 fn test_read_str() {
3020 assert_eq!(from_str("\""), Err(SyntaxError(EOFWhileParsingString, 1, 2)));
3021 assert_eq!(from_str("\"lol
"), Err(SyntaxError(EOFWhileParsingString, 1, 5)));
3023 assert_eq!(from_str("\"\""), Ok(String("".to_string())));
3024 assert_eq!(from_str("\"foo
\""), Ok(String("foo
".to_string())));
3025 assert_eq!(from_str("\"\\\"\""), Ok(String("\"".to_string())));
3026 assert_eq!(from_str("\"\\b
\""), Ok(String("\x08
".to_string())));
3027 assert_eq!(from_str("\"\\n
\""), Ok(String("\n".to_string())));
3028 assert_eq!(from_str("\"\\r
\""), Ok(String("\r".to_string())));
3029 assert_eq!(from_str("\"\\t
\""), Ok(String("\t".to_string())));
3030 assert_eq!(from_str(" \"foo
\" "), Ok(String("foo
".to_string())));
3031 assert_eq!(from_str("\"\\u12ab
\""), Ok(String("\u{12ab}".to_string())));
3032 assert_eq!(from_str("\"\\uAB12
\""), Ok(String("\u{AB12}".to_string())));
3036 fn test_decode_str() {
3037 let s = [("\"\"", ""),
3040 ("\"\\b
\"", "\x08
"),
3044 ("\"\\u12ab
\"", "\u{12ab}"),
3045 ("\"\\uAB12
\"", "\u{AB12}")];
3048 let v: string::String = super::decode(i).unwrap();
3054 fn test_read_array() {
3055 assert_eq!(from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
3056 assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
3057 assert_eq!(from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
3058 assert_eq!(from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
3059 assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
3061 assert_eq!(from_str("[]"), Ok(Array(vec![])));
3062 assert_eq!(from_str("[ ]"), Ok(Array(vec![])));
3063 assert_eq!(from_str("[true]"), Ok(Array(vec![Boolean(true)])));
3064 assert_eq!(from_str("[ false ]"), Ok(Array(vec![Boolean(false)])));
3065 assert_eq!(from_str("[null
]"), Ok(Array(vec![Null])));
3066 assert_eq!(from_str("[3, 1]"),
3067 Ok(Array(vec![U64(3), U64(1)])));
3068 assert_eq!(from_str("\n[3, 2]\n"),
3069 Ok(Array(vec![U64(3), U64(2)])));
3070 assert_eq!(from_str("[2, [4, 1]]"),
3071 Ok(Array(vec![U64(2), Array(vec![U64(4), U64(1)])])));
3075 fn test_decode_array() {
3076 let v: Vec<()> = super::decode("[]").unwrap();
3077 assert_eq!(v, vec![]);
3079 let v: Vec<()> = super::decode("[null
]").unwrap();
3080 assert_eq!(v, vec![()]);
3082 let v: Vec<bool> = super::decode("[true]").unwrap();
3083 assert_eq!(v, vec![true]);
3085 let v: Vec<int> = super::decode("[3, 1]").unwrap();
3086 assert_eq!(v, vec![3, 1]);
3088 let v: Vec<Vec<uint>> = super::decode("[[3], [1, 2]]").unwrap();
3089 assert_eq!(v, vec![vec![3], vec![1, 2]]);
3093 fn test_decode_tuple() {
3094 let t: (uint, uint, uint) = super::decode("[1, 2, 3]").unwrap();
3095 assert_eq!(t, (1, 2, 3));
3097 let t: (uint, string::String) = super::decode("[1, \"two
\"]").unwrap();
3098 assert_eq!(t, (1, "two
".to_string()));
3102 fn test_decode_tuple_malformed_types() {
3103 assert!(super::decode::<(uint, string::String)>("[1, 2]").is_err());
3107 fn test_decode_tuple_malformed_length() {
3108 assert!(super::decode::<(uint, uint)>("[1, 2, 3]").is_err());
3112 fn test_read_object() {
3113 assert_eq!(from_str("{"), Err(SyntaxError(EOFWhileParsingObject, 1, 2)));
3114 assert_eq!(from_str("{ "), Err(SyntaxError(EOFWhileParsingObject, 1, 3)));
3115 assert_eq!(from_str("{1"), Err(SyntaxError(KeyMustBeAString, 1, 2)));
3116 assert_eq!(from_str("{ \"a
\""), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
3117 assert_eq!(from_str("{\"a
\""), Err(SyntaxError(EOFWhileParsingObject, 1, 5)));
3118 assert_eq!(from_str("{\"a
\" "), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
3120 assert_eq!(from_str("{\"a
\" 1"), Err(SyntaxError(ExpectedColon, 1, 6)));
3121 assert_eq!(from_str("{\"a
\":"), Err(SyntaxError(EOFWhileParsingValue, 1, 6)));
3122 assert_eq!(from_str("{\"a
\":1"), Err(SyntaxError(EOFWhileParsingObject, 1, 7)));
3123 assert_eq!(from_str("{\"a
\":1 1"), Err(SyntaxError(InvalidSyntax, 1, 8)));
3124 assert_eq!(from_str("{\"a
\":1,"), Err(SyntaxError(EOFWhileParsingObject, 1, 8)));
3126 assert_eq!(from_str("{}
").unwrap(), mk_object(&[]));
3127 assert_eq!(from_str("{\"a\": 3}
").unwrap(),
3128 mk_object(&[("a
".to_string(), U64(3))]));
3130 assert_eq!(from_str(
3131 "{ \"a\": null, \"b\" : true }
").unwrap(),
3133 ("a
".to_string(), Null),
3134 ("b
".to_string(), Boolean(true))]));
3135 assert_eq!(from_str("\n{ \"a\": null, \"b\" : true }
\n").unwrap(),
3137 ("a
".to_string(), Null),
3138 ("b
".to_string(), Boolean(true))]));
3139 assert_eq!(from_str(
3140 "{\"a\" : 1.0 ,\"b\": [ true ]}
").unwrap(),
3142 ("a
".to_string(), F64(1.0)),
3143 ("b
".to_string(), Array(vec![Boolean(true)]))
3145 assert_eq!(from_str(
3151 { \"c\": {\"d\": null}
} \
3155 ("a
".to_string(), F64(1.0)),
3156 ("b
".to_string(), Array(vec![
3158 String("foo
\nbar
".to_string()),
3160 ("c
".to_string(), mk_object(&[("d
".to_string(), Null)]))
3167 fn test_decode_struct() {
3170 { \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] }
3174 let v: Outer = super::decode(s).unwrap();
3179 Inner { a: (), b: 2, c: vec!["abc".to_string(), "xyz".to_string()] }
3185 #[derive(RustcDecodable)]
3186 struct FloatStruct {
3191 fn test_decode_struct_with_nan() {
3192 let s = "{\"f\":null,\"a\":[null,123]}
";
3193 let obj: FloatStruct = super::decode(s).unwrap();
3194 assert!(obj.f.is_nan());
3195 assert!(obj.a[0].is_nan());
3196 assert_eq!(obj.a[1], 123f64);
3200 fn test_decode_option() {
3201 let value: Option<string::String> = super::decode("null
").unwrap();
3202 assert_eq!(value, None);
3204 let value: Option<string::String> = super::decode("\"jodhpurs
\"").unwrap();
3205 assert_eq!(value, Some("jodhpurs
".to_string()));
3209 fn test_decode_enum() {
3210 let value: Animal = super::decode("\"Dog
\"").unwrap();
3211 assert_eq!(value, Dog);
3213 let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}
";
3214 let value: Animal = super::decode(s).unwrap();
3215 assert_eq!(value, Frog("Henry
".to_string(), 349));
3219 fn test_decode_map() {
3220 let s = "{\"a
\": \"Dog
\", \"b
\": {\"variant
\":\"Frog
\",\
3221 \"fields
\":[\"Henry
\", 349]}}";
3222 let mut map: BTreeMap<string::String, Animal> = super::decode(s).unwrap();
3224 assert_eq!(map.remove(&"a
".to_string()), Some(Dog));
3225 assert_eq!(map.remove(&"b
".to_string()), Some(Frog("Henry
".to_string(), 349)));
3229 fn test_multiline_errors() {
3230 assert_eq!(from_str("{\n \"foo
\":\n \"bar
\""),
3231 Err(SyntaxError(EOFWhileParsingObject, 3, 8)));
3234 #[derive(RustcDecodable)]
3236 struct DecodeStruct {
3240 w: Vec<DecodeStruct>
3242 #[derive(RustcDecodable)]
3247 fn check_err<T: Decodable>(to_parse: &'static str, expected: DecoderError) {
3248 let res: DecodeResult<T> = match from_str(to_parse) {
3249 Err(e) => Err(ParseError(e)),
3250 Ok(json) => Decodable::decode(&mut Decoder::new(json))
3253 Ok(_) => panic!("`{:?}` parsed
& decoded ok
, expecting error `{:?}`
",
3254 to_parse, expected),
3255 Err(ParseError(e)) => panic!("`{:?}` is not valid json
: {:?}
",
3258 assert_eq!(e, expected);
3263 fn test_decode_errors_struct() {
3264 check_err::<DecodeStruct>("[]", ExpectedError("Object
".to_string(), "[]".to_string()));
3265 check_err::<DecodeStruct>("{\"x\": true, \"y\": true, \"z\": \"\", \"w\": []}
",
3266 ExpectedError("Number
".to_string(), "true".to_string()));
3267 check_err::<DecodeStruct>("{\"x\": 1, \"y\": [], \"z\": \"\", \"w\": []}
",
3268 ExpectedError("Boolean
".to_string(), "[]".to_string()));
3269 check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": {}
, \"w
\": []}",
3270 ExpectedError("String
".to_string(), "{}
".to_string()));
3271 check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\", \"w\": null}
",
3272 ExpectedError("Array
".to_string(), "null
".to_string()));
3273 check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\"}
",
3274 MissingFieldError("w
".to_string()));
3277 fn test_decode_errors_enum() {
3278 check_err::<DecodeEnum>("{}
",
3279 MissingFieldError("variant
".to_string()));
3280 check_err::<DecodeEnum>("{\"variant\": 1}
",
3281 ExpectedError("String
".to_string(), "1".to_string()));
3282 check_err::<DecodeEnum>("{\"variant\": \"A\"}
",
3283 MissingFieldError("fields
".to_string()));
3284 check_err::<DecodeEnum>("{\"variant\": \"A\", \"fields\": null}
",
3285 ExpectedError("Array
".to_string(), "null
".to_string()));
3286 check_err::<DecodeEnum>("{\"variant\": \"C\", \"fields\": []}
",
3287 UnknownVariantError("C
".to_string()));
3292 let json_value = from_str("{\"dog\" : \"cat\"}
").unwrap();
3293 let found_str = json_value.find("dog
");
3294 assert!(found_str.unwrap().as_string().unwrap() == "cat
");
3298 fn test_find_path(){
3299 let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}
}}").unwrap();
3300 let found_str = json_value.find_path(&["dog
", "cat
", "mouse
"]);
3301 assert!(found_str.unwrap().as_string().unwrap() == "cheese
");
3306 let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}
}}").unwrap();
3307 let found_str = json_value.search("mouse
").and_then(|j| j.as_string());
3308 assert!(found_str.unwrap() == "cheese
");
3313 let json_value = from_str("{\"animals\":[\"dog\",\"cat\",\"mouse\"]}
").unwrap();
3314 let ref array = json_value["animals
"];
3315 assert_eq!(array[0].as_string().unwrap(), "dog
");
3316 assert_eq!(array[1].as_string().unwrap(), "cat
");
3317 assert_eq!(array[2].as_string().unwrap(), "mouse
");
3321 fn test_is_object(){
3322 let json_value = from_str("{}
").unwrap();
3323 assert!(json_value.is_object());
3327 fn test_as_object(){
3328 let json_value = from_str("{}
").unwrap();
3329 let json_object = json_value.as_object();
3330 assert!(json_object.is_some());
3335 let json_value = from_str("[1, 2, 3]").unwrap();
3336 assert!(json_value.is_array());
3341 let json_value = from_str("[1, 2, 3]").unwrap();
3342 let json_array = json_value.as_array();
3343 let expected_length = 3;
3344 assert!(json_array.is_some() && json_array.unwrap().len() == expected_length);
3348 fn test_is_string(){
3349 let json_value = from_str("\"dog
\"").unwrap();
3350 assert!(json_value.is_string());
3354 fn test_as_string(){
3355 let json_value = from_str("\"dog
\"").unwrap();
3356 let json_str = json_value.as_string();
3357 let expected_str = "dog
";
3358 assert_eq!(json_str, Some(expected_str));
3362 fn test_is_number(){
3363 let json_value = from_str("12").unwrap();
3364 assert!(json_value.is_number());
3369 let json_value = from_str("-12").unwrap();
3370 assert!(json_value.is_i64());
3372 let json_value = from_str("12").unwrap();
3373 assert!(!json_value.is_i64());
3375 let json_value = from_str("12.0").unwrap();
3376 assert!(!json_value.is_i64());
3381 let json_value = from_str("12").unwrap();
3382 assert!(json_value.is_u64());
3384 let json_value = from_str("-12").unwrap();
3385 assert!(!json_value.is_u64());
3387 let json_value = from_str("12.0").unwrap();
3388 assert!(!json_value.is_u64());
3393 let json_value = from_str("12").unwrap();
3394 assert!(!json_value.is_f64());
3396 let json_value = from_str("-12").unwrap();
3397 assert!(!json_value.is_f64());
3399 let json_value = from_str("12.0").unwrap();
3400 assert!(json_value.is_f64());
3402 let json_value = from_str("-12.0").unwrap();
3403 assert!(json_value.is_f64());
3408 let json_value = from_str("-12").unwrap();
3409 let json_num = json_value.as_i64();
3410 assert_eq!(json_num, Some(-12));
3415 let json_value = from_str("12").unwrap();
3416 let json_num = json_value.as_u64();
3417 assert_eq!(json_num, Some(12));
3422 let json_value = from_str("12.0").unwrap();
3423 let json_num = json_value.as_f64();
3424 assert_eq!(json_num, Some(12f64));
3428 fn test_is_boolean(){
3429 let json_value = from_str("false").unwrap();
3430 assert!(json_value.is_boolean());
3434 fn test_as_boolean(){
3435 let json_value = from_str("false").unwrap();
3436 let json_bool = json_value.as_boolean();
3437 let expected_bool = false;
3438 assert!(json_bool.is_some() && json_bool.unwrap() == expected_bool);
3443 let json_value = from_str("null
").unwrap();
3444 assert!(json_value.is_null());
3449 let json_value = from_str("null
").unwrap();
3450 let json_null = json_value.as_null();
3451 let expected_null = ();
3452 assert!(json_null.is_some() && json_null.unwrap() == expected_null);
3456 fn test_encode_hashmap_with_numeric_key() {
3457 use std::str::from_utf8;
3458 use std::old_io::Writer;
3459 use std::collections::HashMap;
3460 let mut hm: HashMap<uint, bool> = HashMap::new();
3462 let mut mem_buf = Vec::new();
3463 write!(&mut mem_buf, "{}
", super::as_pretty_json(&hm)).unwrap();
3464 let json_str = from_utf8(&mem_buf[..]).unwrap();
3465 match from_str(json_str) {
3466 Err(_) => panic!("Unable to parse json_str
: {:?}
", json_str),
3467 _ => {} // it parsed and we are good to go
3472 fn test_prettyencode_hashmap_with_numeric_key() {
3473 use std::str::from_utf8;
3474 use std::old_io::Writer;
3475 use std::collections::HashMap;
3476 let mut hm: HashMap<uint, bool> = HashMap::new();
3478 let mut mem_buf = Vec::new();
3479 write!(&mut mem_buf, "{}
", super::as_pretty_json(&hm)).unwrap();
3480 let json_str = from_utf8(&mem_buf[..]).unwrap();
3481 match from_str(json_str) {
3482 Err(_) => panic!("Unable to parse json_str
: {:?}
", json_str),
3483 _ => {} // it parsed and we are good to go
3488 fn test_prettyencoder_indent_level_param() {
3489 use std::str::from_utf8;
3490 use std::collections::BTreeMap;
3492 let mut tree = BTreeMap::new();
3494 tree.insert("hello
".to_string(), String("guten tag
".to_string()));
3495 tree.insert("goodbye
".to_string(), String("sayonara
".to_string()));
3498 // The following layout below should look a lot like
3499 // the pretty-printed JSON (indent * x)
3502 String("greetings
".to_string()), // 1x
3503 Object(tree), // 1x + 2x + 2x + 1x
3505 // End JSON array (7 lines)
3508 // Helper function for counting indents
3509 fn indents(source: &str) -> uint {
3510 let trimmed = source.trim_left_matches(' ');
3511 source.len() - trimmed.len()
3514 // Test up to 4 spaces of indents (more?)
3516 let mut writer = Vec::new();
3517 write!(&mut writer, "{}
",
3518 super::as_pretty_json(&json).indent(i)).unwrap();
3520 let printed = from_utf8(&writer[..]).unwrap();
3522 // Check for indents at each line
3523 let lines: Vec<&str> = printed.lines().collect();
3524 assert_eq!(lines.len(), 7); // JSON should be 7 lines
3526 assert_eq!(indents(lines[0]), 0 * i); // [
3527 assert_eq!(indents(lines[1]), 1 * i); // "greetings
",
3528 assert_eq!(indents(lines[2]), 1 * i); // {
3529 assert_eq!(indents(lines[3]), 2 * i); // "hello
": "guten tag
",
3530 assert_eq!(indents(lines[4]), 2 * i); // "goodbye
": "sayonara
"
3531 assert_eq!(indents(lines[5]), 1 * i); // },
3532 assert_eq!(indents(lines[6]), 0 * i); // ]
3534 // Finally, test that the pretty-printed JSON is valid
3535 from_str(printed).ok().expect("Pretty
-printed JSON is invalid
!");
3540 fn test_hashmap_with_enum_key() {
3541 use std::collections::HashMap;
3543 #[derive(RustcEncodable, Eq, Hash, PartialEq, RustcDecodable, Debug)]
3549 let mut map = HashMap::new();
3550 map.insert(Enum::Foo, 0);
3551 let result = json::encode(&map).unwrap();
3552 assert_eq!(&result[..], r#"{"Foo":0}
"#);
3553 let decoded: HashMap<Enum, _> = json::decode(&result).unwrap();
3554 assert_eq!(map, decoded);
3558 fn test_hashmap_with_numeric_key_can_handle_double_quote_delimited_key() {
3559 use std::collections::HashMap;
3561 let json_str = "{\"1\":true}
";
3562 let json_obj = match from_str(json_str) {
3563 Err(_) => panic!("Unable to parse json_str
: {:?}
", json_str),
3566 let mut decoder = Decoder::new(json_obj);
3567 let _hm: HashMap<uint, bool> = Decodable::decode(&mut decoder).unwrap();
3571 fn test_hashmap_with_numeric_key_will_error_with_string_keys() {
3572 use std::collections::HashMap;
3574 let json_str = "{\"a\":true}
";
3575 let json_obj = match from_str(json_str) {
3576 Err(_) => panic!("Unable to parse json_str
: {:?}
", json_str),
3579 let mut decoder = Decoder::new(json_obj);
3580 let result: Result<HashMap<uint, bool>, DecoderError> = Decodable::decode(&mut decoder);
3581 assert_eq!(result, Err(ExpectedError("Number
".to_string(), "a
".to_string())));
3584 fn assert_stream_equal(src: &str,
3585 expected: Vec<(JsonEvent, Vec<StackElement>)>) {
3586 let mut parser = Parser::new(src.chars());
3589 let evt = match parser.next() {
3593 let (ref expected_evt, ref expected_stack) = expected[i];
3594 if !parser.stack().is_equal_to(expected_stack) {
3595 panic!("Parser stack is not equal to {:?}
", expected_stack);
3597 assert_eq!(&evt, expected_evt);
3602 #[cfg_attr(target_pointer_width = "32", ignore)] // FIXME(#14064)
3603 fn test_streaming_parser() {
3604 assert_stream_equal(
3605 r#"{ "foo":"bar", "array" : [0, 1, 2, 3, 4, 5], "idents":[null,true,false]}
"#,
3607 (ObjectStart, vec![]),
3608 (StringValue("bar
".to_string()), vec![StackElement::Key("foo
")]),
3609 (ArrayStart, vec![StackElement::Key("array
")]),
3610 (U64Value(0), vec![StackElement::Key("array
"), StackElement::Index(0)]),
3611 (U64Value(1), vec![StackElement::Key("array
"), StackElement::Index(1)]),
3612 (U64Value(2), vec![StackElement::Key("array
"), StackElement::Index(2)]),
3613 (U64Value(3), vec![StackElement::Key("array
"), StackElement::Index(3)]),
3614 (U64Value(4), vec![StackElement::Key("array
"), StackElement::Index(4)]),
3615 (U64Value(5), vec![StackElement::Key("array
"), StackElement::Index(5)]),
3616 (ArrayEnd, vec![StackElement::Key("array
")]),
3617 (ArrayStart, vec![StackElement::Key("idents
")]),
3618 (NullValue, vec![StackElement::Key("idents
"),
3619 StackElement::Index(0)]),
3620 (BooleanValue(true), vec![StackElement::Key("idents
"),
3621 StackElement::Index(1)]),
3622 (BooleanValue(false), vec![StackElement::Key("idents
"),
3623 StackElement::Index(2)]),
3624 (ArrayEnd, vec![StackElement::Key("idents
")]),
3625 (ObjectEnd, vec![]),
3629 fn last_event(src: &str) -> JsonEvent {
3630 let mut parser = Parser::new(src.chars());
3631 let mut evt = NullValue;
3633 evt = match parser.next() {
3641 #[cfg_attr(target_pointer_width = "32", ignore)] // FIXME(#14064)
3642 fn test_read_object_streaming() {
3643 assert_eq!(last_event("{ "), Error(SyntaxError(EOFWhileParsingObject, 1, 3)));
3644 assert_eq!(last_event("{1"), Error(SyntaxError(KeyMustBeAString, 1, 2)));
3645 assert_eq!(last_event("{ \"a
\""), Error(SyntaxError(EOFWhileParsingObject, 1, 6)));
3646 assert_eq!(last_event("{\"a
\""), Error(SyntaxError(EOFWhileParsingObject, 1, 5)));
3647 assert_eq!(last_event("{\"a
\" "), Error(SyntaxError(EOFWhileParsingObject, 1, 6)));
3649 assert_eq!(last_event("{\"a
\" 1"), Error(SyntaxError(ExpectedColon, 1, 6)));
3650 assert_eq!(last_event("{\"a
\":"), Error(SyntaxError(EOFWhileParsingValue, 1, 6)));
3651 assert_eq!(last_event("{\"a
\":1"), Error(SyntaxError(EOFWhileParsingObject, 1, 7)));
3652 assert_eq!(last_event("{\"a
\":1 1"), Error(SyntaxError(InvalidSyntax, 1, 8)));
3653 assert_eq!(last_event("{\"a
\":1,"), Error(SyntaxError(EOFWhileParsingObject, 1, 8)));
3654 assert_eq!(last_event("{\"a\":1,}
"), Error(SyntaxError(TrailingComma, 1, 8)));
3656 assert_stream_equal(
3658 vec![(ObjectStart, vec![]), (ObjectEnd, vec![])]
3660 assert_stream_equal(
3663 (ObjectStart, vec![]),
3664 (U64Value(3), vec![StackElement::Key("a
")]),
3665 (ObjectEnd, vec![]),
3668 assert_stream_equal(
3669 "{ \"a\": null, \"b\" : true }
",
3671 (ObjectStart, vec![]),
3672 (NullValue, vec![StackElement::Key("a
")]),
3673 (BooleanValue(true), vec![StackElement::Key("b
")]),
3674 (ObjectEnd, vec![]),
3677 assert_stream_equal(
3678 "{\"a\" : 1.0 ,\"b\": [ true ]}
",
3680 (ObjectStart, vec![]),
3681 (F64Value(1.0), vec![StackElement::Key("a
")]),
3682 (ArrayStart, vec![StackElement::Key("b
")]),
3683 (BooleanValue(true),vec![StackElement::Key("b
"), StackElement::Index(0)]),
3684 (ArrayEnd, vec![StackElement::Key("b
")]),
3685 (ObjectEnd, vec![]),
3688 assert_stream_equal(
3694 { "c": {"d": null}
}
3698 (ObjectStart, vec![]),
3699 (F64Value(1.0), vec![StackElement::Key("a
")]),
3700 (ArrayStart, vec![StackElement::Key("b
")]),
3701 (BooleanValue(true), vec![StackElement::Key("b
"),
3702 StackElement::Index(0)]),
3703 (StringValue("foo
\nbar
".to_string()), vec![StackElement::Key("b
"),
3704 StackElement::Index(1)]),
3705 (ObjectStart, vec![StackElement::Key("b
"),
3706 StackElement::Index(2)]),
3707 (ObjectStart, vec![StackElement::Key("b
"),
3708 StackElement::Index(2),
3709 StackElement::Key("c
")]),
3710 (NullValue, vec![StackElement::Key("b
"),
3711 StackElement::Index(2),
3712 StackElement::Key("c
"),
3713 StackElement::Key("d
")]),
3714 (ObjectEnd, vec![StackElement::Key("b
"),
3715 StackElement::Index(2),
3716 StackElement::Key("c
")]),
3717 (ObjectEnd, vec![StackElement::Key("b
"),
3718 StackElement::Index(2)]),
3719 (ArrayEnd, vec![StackElement::Key("b
")]),
3720 (ObjectEnd, vec![]),
3725 #[cfg_attr(target_pointer_width = "32", ignore)] // FIXME(#14064)
3726 fn test_read_array_streaming() {
3727 assert_stream_equal(
3730 (ArrayStart, vec![]),
3734 assert_stream_equal(
3737 (ArrayStart, vec![]),
3741 assert_stream_equal(
3744 (ArrayStart, vec![]),
3745 (BooleanValue(true), vec![StackElement::Index(0)]),
3749 assert_stream_equal(
3752 (ArrayStart, vec![]),
3753 (BooleanValue(false), vec![StackElement::Index(0)]),
3757 assert_stream_equal(
3760 (ArrayStart, vec![]),
3761 (NullValue, vec![StackElement::Index(0)]),
3765 assert_stream_equal(
3768 (ArrayStart, vec![]),
3769 (U64Value(3), vec![StackElement::Index(0)]),
3770 (U64Value(1), vec![StackElement::Index(1)]),
3774 assert_stream_equal(
3777 (ArrayStart, vec![]),
3778 (U64Value(3), vec![StackElement::Index(0)]),
3779 (U64Value(2), vec![StackElement::Index(1)]),
3783 assert_stream_equal(
3786 (ArrayStart, vec![]),
3787 (U64Value(2), vec![StackElement::Index(0)]),
3788 (ArrayStart, vec![StackElement::Index(1)]),
3789 (U64Value(4), vec![StackElement::Index(1), StackElement::Index(0)]),
3790 (U64Value(1), vec![StackElement::Index(1), StackElement::Index(1)]),
3791 (ArrayEnd, vec![StackElement::Index(1)]),
3796 assert_eq!(last_event("["), Error(SyntaxError(EOFWhileParsingValue, 1, 2)));
3798 assert_eq!(from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
3799 assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
3800 assert_eq!(from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
3801 assert_eq!(from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
3802 assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
3806 fn test_trailing_characters_streaming() {
3807 assert_eq!(last_event("nulla
"), Error(SyntaxError(TrailingCharacters, 1, 5)));
3808 assert_eq!(last_event("truea
"), Error(SyntaxError(TrailingCharacters, 1, 5)));
3809 assert_eq!(last_event("falsea
"), Error(SyntaxError(TrailingCharacters, 1, 6)));
3810 assert_eq!(last_event("1a
"), Error(SyntaxError(TrailingCharacters, 1, 2)));
3811 assert_eq!(last_event("[]a
"), Error(SyntaxError(TrailingCharacters, 1, 3)));
3812 assert_eq!(last_event("{}a
"), Error(SyntaxError(TrailingCharacters, 1, 3)));
3815 fn test_read_identifiers_streaming() {
3816 assert_eq!(Parser::new("null
".chars()).next(), Some(NullValue));
3817 assert_eq!(Parser::new("true".chars()).next(), Some(BooleanValue(true)));
3818 assert_eq!(Parser::new("false".chars()).next(), Some(BooleanValue(false)));
3820 assert_eq!(last_event("n
"), Error(SyntaxError(InvalidSyntax, 1, 2)));
3821 assert_eq!(last_event("nul
"), Error(SyntaxError(InvalidSyntax, 1, 4)));
3822 assert_eq!(last_event("t
"), Error(SyntaxError(InvalidSyntax, 1, 2)));
3823 assert_eq!(last_event("truz
"), Error(SyntaxError(InvalidSyntax, 1, 4)));
3824 assert_eq!(last_event("f
"), Error(SyntaxError(InvalidSyntax, 1, 2)));
3825 assert_eq!(last_event("faz
"), Error(SyntaxError(InvalidSyntax, 1, 3)));
3830 let mut stack = Stack::new();
3832 assert!(stack.is_empty());
3833 assert!(stack.len() == 0);
3834 assert!(!stack.last_is_index());
3836 stack.push_index(0);
3839 assert!(stack.len() == 1);
3840 assert!(stack.is_equal_to(&[StackElement::Index(1)]));
3841 assert!(stack.starts_with(&[StackElement::Index(1)]));
3842 assert!(stack.ends_with(&[StackElement::Index(1)]));
3843 assert!(stack.last_is_index());
3844 assert!(stack.get(0) == StackElement::Index(1));
3846 stack.push_key("foo
".to_string());
3848 assert!(stack.len() == 2);
3849 assert!(stack.is_equal_to(&[StackElement::Index(1), StackElement::Key("foo
")]));
3850 assert!(stack.starts_with(&[StackElement::Index(1), StackElement::Key("foo
")]));
3851 assert!(stack.starts_with(&[StackElement::Index(1)]));
3852 assert!(stack.ends_with(&[StackElement::Index(1), StackElement::Key("foo
")]));
3853 assert!(stack.ends_with(&[StackElement::Key("foo
")]));
3854 assert!(!stack.last_is_index());
3855 assert!(stack.get(0) == StackElement::Index(1));
3856 assert!(stack.get(1) == StackElement::Key("foo
"));
3858 stack.push_key("bar
".to_string());
3860 assert!(stack.len() == 3);
3861 assert!(stack.is_equal_to(&[StackElement::Index(1),
3862 StackElement::Key("foo
"),
3863 StackElement::Key("bar
")]));
3864 assert!(stack.starts_with(&[StackElement::Index(1)]));
3865 assert!(stack.starts_with(&[StackElement::Index(1), StackElement::Key("foo
")]));
3866 assert!(stack.starts_with(&[StackElement::Index(1),
3867 StackElement::Key("foo
"),
3868 StackElement::Key("bar
")]));
3869 assert!(stack.ends_with(&[StackElement::Key("bar
")]));
3870 assert!(stack.ends_with(&[StackElement::Key("foo
"), StackElement::Key("bar
")]));
3871 assert!(stack.ends_with(&[StackElement::Index(1),
3872 StackElement::Key("foo
"),
3873 StackElement::Key("bar
")]));
3874 assert!(!stack.last_is_index());
3875 assert!(stack.get(0) == StackElement::Index(1));
3876 assert!(stack.get(1) == StackElement::Key("foo
"));
3877 assert!(stack.get(2) == StackElement::Key("bar
"));
3881 assert!(stack.len() == 2);
3882 assert!(stack.is_equal_to(&[StackElement::Index(1), StackElement::Key("foo
")]));
3883 assert!(stack.starts_with(&[StackElement::Index(1), StackElement::Key("foo
")]));
3884 assert!(stack.starts_with(&[StackElement::Index(1)]));
3885 assert!(stack.ends_with(&[StackElement::Index(1), StackElement::Key("foo
")]));
3886 assert!(stack.ends_with(&[StackElement::Key("foo
")]));
3887 assert!(!stack.last_is_index());
3888 assert!(stack.get(0) == StackElement::Index(1));
3889 assert!(stack.get(1) == StackElement::Key("foo
"));
3894 use std::collections::{HashMap,BTreeMap};
3897 let array2 = Array(vec!(U64(1), U64(2)));
3898 let array3 = Array(vec!(U64(1), U64(2), U64(3)));
3900 let mut tree_map = BTreeMap::new();
3901 tree_map.insert("a
".to_string(), U64(1));
3902 tree_map.insert("b
".to_string(), U64(2));
3906 assert_eq!(array2.to_json(), array2);
3907 assert_eq!(object.to_json(), object);
3908 assert_eq!(3_isize.to_json(), I64(3));
3909 assert_eq!(4_i8.to_json(), I64(4));
3910 assert_eq!(5_i16.to_json(), I64(5));
3911 assert_eq!(6_i32.to_json(), I64(6));
3912 assert_eq!(7_i64.to_json(), I64(7));
3913 assert_eq!(8_usize.to_json(), U64(8));
3914 assert_eq!(9_u8.to_json(), U64(9));
3915 assert_eq!(10_u16.to_json(), U64(10));
3916 assert_eq!(11_u32.to_json(), U64(11));
3917 assert_eq!(12_u64.to_json(), U64(12));
3918 assert_eq!(13.0_f32.to_json(), F64(13.0_f64));
3919 assert_eq!(14.0_f64.to_json(), F64(14.0_f64));
3920 assert_eq!(().to_json(), Null);
3921 assert_eq!(f32::INFINITY.to_json(), Null);
3922 assert_eq!(f64::NAN.to_json(), Null);
3923 assert_eq!(true.to_json(), Boolean(true));
3924 assert_eq!(false.to_json(), Boolean(false));
3925 assert_eq!("abc
".to_json(), String("abc
".to_string()));
3926 assert_eq!("abc
".to_string().to_json(), String("abc
".to_string()));
3927 assert_eq!((1_usize, 2_usize).to_json(), array2);
3928 assert_eq!((1_usize, 2_usize, 3_usize).to_json(), array3);
3929 assert_eq!([1_usize, 2_usize].to_json(), array2);
3930 assert_eq!((&[1_usize, 2_usize, 3_usize]).to_json(), array3);
3931 assert_eq!((vec![1_usize, 2_usize]).to_json(), array2);
3932 assert_eq!(vec!(1_usize, 2_usize, 3_usize).to_json(), array3);
3933 let mut tree_map = BTreeMap::new();
3934 tree_map.insert("a
".to_string(), 1 as usize);
3935 tree_map.insert("b
".to_string(), 2);
3936 assert_eq!(tree_map.to_json(), object);
3937 let mut hash_map = HashMap::new();
3938 hash_map.insert("a
".to_string(), 1 as usize);
3939 hash_map.insert("b
".to_string(), 2);
3940 assert_eq!(hash_map.to_json(), object);
3941 assert_eq!(Some(15).to_json(), I64(15));
3942 assert_eq!(Some(15 as usize).to_json(), U64(15));
3943 assert_eq!(None::<int>.to_json(), Null);
3947 fn test_encode_hashmap_with_arbitrary_key() {
3948 use std::old_io::Writer;
3949 use std::collections::HashMap;
3951 #[derive(PartialEq, Eq, Hash, RustcEncodable)]
3952 struct ArbitraryType(uint);
3953 let mut hm: HashMap<ArbitraryType, bool> = HashMap::new();
3954 hm.insert(ArbitraryType(1), true);
3955 let mut mem_buf = string::String::new();
3956 let mut encoder = Encoder::new(&mut mem_buf);
3957 let result = hm.encode(&mut encoder);
3958 match result.err().unwrap() {
3959 EncoderError::BadHashmapKey => (),
3960 _ => panic!("expected bad hash map key
")
3965 fn bench_streaming_small(b: &mut Bencher) {
3967 let mut parser = Parser::new(
3973 { "c": {"d": null}
}
3978 match parser.next() {
3986 fn bench_small(b: &mut Bencher) {
3988 let _ = from_str(r#"{
3993 { "c": {"d": null}
}
3999 fn big_json() -> string::String {
4000 let mut src = "[\n".to_string();
4002 src.push_str(r#"{ "a": true, "b": null
, "c":3.1415, "d": "Hello world", "e": \
4005 src.push_str("{}
]");
4010 fn bench_streaming_large(b: &mut Bencher) {
4011 let src = big_json();
4013 let mut parser = Parser::new(src.chars());
4015 match parser.next() {
4023 fn bench_large(b: &mut Bencher) {
4024 let src = big_json();
4025 b.iter( || { let _ = from_str(&src); });