src/libserialize/json.rs

   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.
   4 //
   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.
  10
  11 // Rust JSON serialization library
  12 // Copyright (c) 2011 Google Inc.
  13
  14 #![forbid(non_camel_case_types)]
  15 #![allow(missing_docs)]
  16
  17 //! JSON parsing and serialization
  18 //!
  19 //! # What is JSON?
  20 //!
  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.
  24 //!
  25 //! Data types that can be encoded are JavaScript types (see the `Json` enum for more details):
  26 //!
  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
  31 //!   same array
  32 //! * `Object`: equivalent to rust's `BTreeMap<String, json::Json>`
  33 //! * `Null`
  34 //!
  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
  38 //!
  39 //! ```ignore
  40 //! {
  41 //!     "FirstName": "John",
  42 //!     "LastName": "Doe",
  43 //!     "Age": 43,
  44 //!     "Address": {
  45 //!         "Street": "Downing Street 10",
  46 //!         "City": "London",
  47 //!         "Country": "Great Britain"
  48 //!     },
  49 //!     "PhoneNumbers": [
  50 //!         "+44 1234567",
  51 //!         "+44 2345678"
  52 //!     ]
  53 //! }
  54 //! ```
  55 //!
  56 //! # Rust Type-based Encoding and Decoding
  57 //!
  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)]`
  64 //!
  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.
  69 //!
  70 //! When using `ToJson` the `RustcEncodable` trait implementation is not mandatory.
  71 //!
  72 //! # Examples of use
  73 //!
  74 //! ## Using Autoserialization
  75 //!
  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.
  78 //!
  79 //! ```notrust
  80 //! // FIXME(#19470): this cannot be ```rust``` because it fails orphan checking at the moment
  81 //! extern crate serialize;
  82 //! use serialize::json;
  83 //!
  84 //! // Automatically generate `Decodable` and `Encodable` trait implementations
  85 //! #[derive(RustcDecodable, RustcEncodable)]
  86 //! pub struct TestStruct  {
  87 //!     data_int: u8,
  88 //!     data_str: String,
  89 //!     data_vector: Vec<u8>,
  90 //! }
  91 //!
  92 //! fn main() {
  93 //!     let object = TestStruct {
  94 //!         data_int: 1,
  95 //!         data_str: "homura".to_string(),
  96 //!         data_vector: vec![2,3,4,5],
  97 //!     };
  98 //!
  99 //!     // Serialize using `json::encode`
 100 //!     let encoded = json::encode(&object).unwrap();
 101 //!
 102 //!     // Deserialize using `json::decode`
 103 //!     let decoded: TestStruct = json::decode(&encoded[..]).unwrap();
 104 //! }
 105 //! ```
 106 //!
 107 //! ## Using the `ToJson` trait
 108 //!
 109 //! The examples above use the `ToJson` trait to generate the JSON string, which is required
 110 //! for custom mappings.
 111 //!
 112 //! ### Simple example of `ToJson` usage
 113 //!
 114 //! ```notrust
 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};
 118 //!
 119 //! // A custom data structure
 120 //! struct ComplexNum {
 121 //!     a: f64,
 122 //!     b: f64,
 123 //! }
 124 //!
 125 //! // JSON value representation
 126 //! impl ToJson for ComplexNum {
 127 //!     fn to_json(&self) -> Json {
 128 //!         Json::String(format!("{}+{}i", self.a, self.b))
 129 //!     }
 130 //! }
 131 //!
 132 //! // Only generate `RustcEncodable` trait implementation
 133 //! #[derive(Encodable)]
 134 //! pub struct ComplexNumRecord {
 135 //!     uid: u8,
 136 //!     dsc: String,
 137 //!     val: Json,
 138 //! }
 139 //!
 140 //! fn main() {
 141 //!     let num = ComplexNum { a: 0.0001, b: 12.539 };
 142 //!     let data: String = json::encode(&ComplexNumRecord{
 143 //!         uid: 1,
 144 //!         dsc: "test".to_string(),
 145 //!         val: num.to_json(),
 146 //!     }).unwrap();
 147 //!     println!("data: {}", data);
 148 //!     // data: {"uid":1,"dsc":"test","val":"0.0001+12.539i"};
 149 //! }
 150 //! ```
 151 //!
 152 //! ### Verbose example of `ToJson` usage
 153 //!
 154 //! ```notrust
 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};
 159 //!
 160 //! // Only generate `Decodable` trait implementation
 161 //! #[derive(Decodable)]
 162 //! pub struct TestStruct {
 163 //!     data_int: u8,
 164 //!     data_str: String,
 165 //!     data_vector: Vec<u8>,
 166 //! }
 167 //!
 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());
 176 //!         Json::Object(d)
 177 //!     }
 178 //! }
 179 //!
 180 //! fn main() {
 181 //!     // Serialize using `ToJson`
 182 //!     let input_data = TestStruct {
 183 //!         data_int: 1,
 184 //!         data_str: "madoka".to_string(),
 185 //!         data_vector: vec![2,3,4,5],
 186 //!     };
 187 //!     let json_obj: Json = input_data.to_json();
 188 //!     let json_str: String = json_obj.to_string();
 189 //!
 190 //!     // Deserialize like before
 191 //!     let decoded: TestStruct = json::decode(json_str)).unwrap();
 192 //! }
 193 //! ```
 194
 195 use self::JsonEvent::*;
 196 use self::ErrorCode::*;
 197 use self::ParserError::*;
 198 use self::DecoderError::*;
 199 use self::ParserState::*;
 200 use self::InternalStackElement::*;
 201
 202 use std::collections::{HashMap, BTreeMap};
 203 use std::io::prelude::*;
 204 use std::io;
 205 use std::mem::swap;
 206 use std::num::FpCategory as Fp;
 207 use std::ops::Index;
 208 use std::str::FromStr;
 209 use std::string;
 210 use std::{char, f64, fmt, str};
 211 use std;
 212 use rustc_unicode::str as unicode_str;
 213 use rustc_unicode::str::Utf16Item;
 214
 215 use Encodable;
 216
 217 /// Represents a json value
 218 #[derive(Clone, PartialEq, PartialOrd, Debug)]
 219 pub enum Json {
 220     I64(i64),
 221     U64(u64),
 222     F64(f64),
 223     String(string::String),
 224     Boolean(bool),
 225     Array(self::Array),
 226     Object(self::Object),
 227     Null,
 228 }
 229
 230 pub type Array = Vec<Json>;
 231 pub type Object = BTreeMap<string::String, Json>;
 232
 233 pub struct PrettyJson<'a> { inner: &'a Json }
 234
 235 pub struct AsJson<'a, T: 'a> { inner: &'a T }
 236 pub struct AsPrettyJson<'a, T: 'a> { inner: &'a T, indent: Option<usize> }
 237
 238 /// The errors that can arise while parsing a JSON stream.
 239 #[derive(Clone, Copy, PartialEq, Debug)]
 240 pub enum ErrorCode {
 241     InvalidSyntax,
 242     InvalidNumber,
 243     EOFWhileParsingObject,
 244     EOFWhileParsingArray,
 245     EOFWhileParsingValue,
 246     EOFWhileParsingString,
 247     KeyMustBeAString,
 248     ExpectedColon,
 249     TrailingCharacters,
 250     TrailingComma,
 251     InvalidEscape,
 252     InvalidUnicodeCodePoint,
 253     LoneLeadingSurrogateInHexEscape,
 254     UnexpectedEndOfHexEscape,
 255     UnrecognizedHex,
 256     NotFourDigit,
 257     NotUtf8,
 258 }
 259
 260 #[derive(Clone, PartialEq, Debug)]
 261 pub enum ParserError {
 262     /// msg, line, col
 263     SyntaxError(ErrorCode, usize, usize),
 264     IoError(io::ErrorKind, String),
 265 }
 266
 267 // Builder and Parser have the same errors.
 268 pub type BuilderError = ParserError;
 269
 270 #[derive(Clone, PartialEq, Debug)]
 271 pub enum DecoderError {
 272     ParseError(ParserError),
 273     ExpectedError(string::String, string::String),
 274     MissingFieldError(string::String),
 275     UnknownVariantError(string::String),
 276     ApplicationError(string::String)
 277 }
 278
 279 #[derive(Copy, Clone, Debug)]
 280 pub enum EncoderError {
 281     FmtError(fmt::Error),
 282     BadHashmapKey,
 283 }
 284
 285 /// Returns a readable error string for a given error code.
 286 pub fn error_str(error: ErrorCode) -> &'static str {
 287     match error {
 288         InvalidSyntax => "invalid syntax",
 289         InvalidNumber => "invalid number",
 290         EOFWhileParsingObject => "EOF While parsing object",
 291         EOFWhileParsingArray => "EOF While parsing array",
 292         EOFWhileParsingValue => "EOF While parsing value",
 293         EOFWhileParsingString => "EOF While parsing string",
 294         KeyMustBeAString => "key must be a string",
 295         ExpectedColon => "expected `:`",
 296         TrailingCharacters => "trailing characters",
 297         TrailingComma => "trailing comma",
 298         InvalidEscape => "invalid escape",
 299         UnrecognizedHex => "invalid \\u{ esc}ape (unrecognized hex)",
 300         NotFourDigit => "invalid \\u{ esc}ape (not four digits)",
 301         NotUtf8 => "contents not utf-8",
 302         InvalidUnicodeCodePoint => "invalid Unicode code point",
 303         LoneLeadingSurrogateInHexEscape => "lone leading surrogate in hex escape",
 304         UnexpectedEndOfHexEscape => "unexpected end of hex escape",
 305     }
 306 }
 307
 308 /// Shortcut function to decode a JSON `&str` into an object
 309 pub fn decode<T: ::Decodable>(s: &str) -> DecodeResult<T> {
 310     let json = match from_str(s) {
 311         Ok(x) => x,
 312         Err(e) => return Err(ParseError(e))
 313     };
 314
 315     let mut decoder = Decoder::new(json);
 316     ::Decodable::decode(&mut decoder)
 317 }
 318
 319 /// Shortcut function to encode a `T` into a JSON `String`
 320 pub fn encode<T: ::Encodable>(object: &T) -> Result<string::String, EncoderError> {
 321     let mut s = String::new();
 322     {
 323         let mut encoder = Encoder::new(&mut s);
 324         try!(object.encode(&mut encoder));
 325     }
 326     Ok(s)
 327 }
 328
 329 impl fmt::Display for ErrorCode {
 330     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 331         error_str(*self).fmt(f)
 332     }
 333 }
 334
 335 fn io_error_to_error(io: io::Error) -> ParserError {
 336     IoError(io.kind(), io.to_string())
 337 }
 338
 339 impl fmt::Display for ParserError {
 340     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 341         // FIXME this should be a nicer error
 342         fmt::Debug::fmt(self, f)
 343     }
 344 }
 345
 346 impl fmt::Display for DecoderError {
 347     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 348         // FIXME this should be a nicer error
 349         fmt::Debug::fmt(self, f)
 350     }
 351 }
 352
 353 impl std::error::Error for DecoderError {
 354     fn description(&self) -> &str { "decoder error" }
 355 }
 356
 357 impl fmt::Display for EncoderError {
 358     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 359         // FIXME this should be a nicer error
 360         fmt::Debug::fmt(self, f)
 361     }
 362 }
 363
 364 impl std::error::Error for EncoderError {
 365     fn description(&self) -> &str { "encoder error" }
 366 }
 367
 368 impl From<fmt::Error> for EncoderError {
 369     fn from(err: fmt::Error) -> EncoderError { EncoderError::FmtError(err) }
 370 }
 371
 372 pub type EncodeResult = Result<(), EncoderError>;
 373 pub type DecodeResult<T> = Result<T, DecoderError>;
 374
 375 fn escape_str(wr: &mut fmt::Write, v: &str) -> EncodeResult {
 376     try!(wr.write_str("\""));
 377
 378     let mut start = 0;
 379
 380     for (i, byte) in v.bytes().enumerate() {
 381         let escaped = match byte {
 382             b'"' => "\\\"",
 383             b'\\' => "\\\\",
 384             b'\x00' => "\\u0000",
 385             b'\x01' => "\\u0001",
 386             b'\x02' => "\\u0002",
 387             b'\x03' => "\\u0003",
 388             b'\x04' => "\\u0004",
 389             b'\x05' => "\\u0005",
 390             b'\x06' => "\\u0006",
 391             b'\x07' => "\\u0007",
 392             b'\x08' => "\\b",
 393             b'\t' => "\\t",
 394             b'\n' => "\\n",
 395             b'\x0b' => "\\u000b",
 396             b'\x0c' => "\\f",
 397             b'\r' => "\\r",
 398             b'\x0e' => "\\u000e",
 399             b'\x0f' => "\\u000f",
 400             b'\x10' => "\\u0010",
 401             b'\x11' => "\\u0011",
 402             b'\x12' => "\\u0012",
 403             b'\x13' => "\\u0013",
 404             b'\x14' => "\\u0014",
 405             b'\x15' => "\\u0015",
 406             b'\x16' => "\\u0016",
 407             b'\x17' => "\\u0017",
 408             b'\x18' => "\\u0018",
 409             b'\x19' => "\\u0019",
 410             b'\x1a' => "\\u001a",
 411             b'\x1b' => "\\u001b",
 412             b'\x1c' => "\\u001c",
 413             b'\x1d' => "\\u001d",
 414             b'\x1e' => "\\u001e",
 415             b'\x1f' => "\\u001f",
 416             b'\x7f' => "\\u007f",
 417             _ => { continue; }
 418         };
 419
 420         if start < i {
 421             try!(wr.write_str(&v[start..i]));
 422         }
 423
 424         try!(wr.write_str(escaped));
 425
 426         start = i + 1;
 427     }
 428
 429     if start != v.len() {
 430         try!(wr.write_str(&v[start..]));
 431     }
 432
 433     try!(wr.write_str("\""));
 434     Ok(())
 435 }
 436
 437 fn escape_char(writer: &mut fmt::Write, v: char) -> EncodeResult {
 438     let mut buf = [0; 4];
 439     let n = v.encode_utf8(&mut buf).unwrap();
 440     let buf = unsafe { str::from_utf8_unchecked(&buf[..n]) };
 441     escape_str(writer, buf)
 442 }
 443
 444 fn spaces(wr: &mut fmt::Write, mut n: usize) -> EncodeResult {
 445     const BUF: &'static str = "                ";
 446
 447     while n >= BUF.len() {
 448         try!(wr.write_str(BUF));
 449         n -= BUF.len();
 450     }
 451
 452     if n > 0 {
 453         try!(wr.write_str(&BUF[..n]));
 454     }
 455     Ok(())
 456 }
 457
 458 fn fmt_number_or_null(v: f64) -> string::String {
 459     match v.classify() {
 460         Fp::Nan | Fp::Infinite => string::String::from("null"),
 461         _ if v.fract() != 0f64 => v.to_string(),
 462         _ => v.to_string() + ".0",
 463     }
 464 }
 465
 466 /// A structure for implementing serialization to JSON.
 467 pub struct Encoder<'a> {
 468     writer: &'a mut (fmt::Write+'a),
 469     is_emitting_map_key: bool,
 470 }
 471
 472 impl<'a> Encoder<'a> {
 473     /// Creates a new JSON encoder whose output will be written to the writer
 474     /// specified.
 475     pub fn new(writer: &'a mut fmt::Write) -> Encoder<'a> {
 476         Encoder { writer: writer, is_emitting_map_key: false, }
 477     }
 478 }
 479
 480 macro_rules! emit_enquoted_if_mapkey {
 481     ($enc:ident,$e:expr) => {
 482         if $enc.is_emitting_map_key {
 483             try!(write!($enc.writer, "\"{}\"", $e));
 484             Ok(())
 485         } else {
 486             try!(write!($enc.writer, "{}", $e));
 487             Ok(())
 488         }
 489     }
 490 }
 491
 492 impl<'a> ::Encoder for Encoder<'a> {
 493     type Error = EncoderError;
 494
 495     fn emit_nil(&mut self) -> EncodeResult {
 496         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 497         try!(write!(self.writer, "null"));
 498         Ok(())
 499     }
 500
 501     fn emit_uint(&mut self, v: usize) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 502     fn emit_u64(&mut self, v: u64) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 503     fn emit_u32(&mut self, v: u32) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 504     fn emit_u16(&mut self, v: u16) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 505     fn emit_u8(&mut self, v: u8) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 506
 507     fn emit_int(&mut self, v: isize) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 508     fn emit_i64(&mut self, v: i64) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 509     fn emit_i32(&mut self, v: i32) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 510     fn emit_i16(&mut self, v: i16) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 511     fn emit_i8(&mut self, v: i8) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 512
 513     fn emit_bool(&mut self, v: bool) -> EncodeResult {
 514         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 515         if v {
 516             try!(write!(self.writer, "true"));
 517         } else {
 518             try!(write!(self.writer, "false"));
 519         }
 520         Ok(())
 521     }
 522
 523     fn emit_f64(&mut self, v: f64) -> EncodeResult {
 524         emit_enquoted_if_mapkey!(self, fmt_number_or_null(v))
 525     }
 526     fn emit_f32(&mut self, v: f32) -> EncodeResult {
 527         self.emit_f64(v as f64)
 528     }
 529
 530     fn emit_char(&mut self, v: char) -> EncodeResult {
 531         escape_char(self.writer, v)
 532     }
 533     fn emit_str(&mut self, v: &str) -> EncodeResult {
 534         escape_str(self.writer, v)
 535     }
 536
 537     fn emit_enum<F>(&mut self, _name: &str, f: F) -> EncodeResult where
 538         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 539     {
 540         f(self)
 541     }
 542
 543     fn emit_enum_variant<F>(&mut self,
 544                             name: &str,
 545                             _id: usize,
 546                             cnt: usize,
 547                             f: F) -> EncodeResult where
 548         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 549     {
 550         // enums are encoded as strings or objects
 551         // Bunny => "Bunny"
 552         // Kangaroo(34,"William") => {"variant": "Kangaroo", "fields": [34,"William"]}
 553         if cnt == 0 {
 554             escape_str(self.writer, name)
 555         } else {
 556             if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 557             try!(write!(self.writer, "{{\"variant\":"));
 558             try!(escape_str(self.writer, name));
 559             try!(write!(self.writer, ",\"fields\":["));
 560             try!(f(self));
 561             try!(write!(self.writer, "]}}"));
 562             Ok(())
 563         }
 564     }
 565
 566     fn emit_enum_variant_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult where
 567         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 568     {
 569         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 570         if idx != 0 {
 571             try!(write!(self.writer, ","));
 572         }
 573         f(self)
 574     }
 575
 576     fn emit_enum_struct_variant<F>(&mut self,
 577                                    name: &str,
 578                                    id: usize,
 579                                    cnt: usize,
 580                                    f: F) -> EncodeResult where
 581         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 582     {
 583         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 584         self.emit_enum_variant(name, id, cnt, f)
 585     }
 586
 587     fn emit_enum_struct_variant_field<F>(&mut self,
 588                                          _: &str,
 589                                          idx: usize,
 590                                          f: F) -> EncodeResult where
 591         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 592     {
 593         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 594         self.emit_enum_variant_arg(idx, f)
 595     }
 596
 597     fn emit_struct<F>(&mut self, _: &str, _: usize, f: F) -> EncodeResult where
 598         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 599     {
 600         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 601         try!(write!(self.writer, "{{"));
 602         try!(f(self));
 603         try!(write!(self.writer, "}}"));
 604         Ok(())
 605     }
 606
 607     fn emit_struct_field<F>(&mut self, name: &str, idx: usize, f: F) -> EncodeResult where
 608         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 609     {
 610         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 611         if idx != 0 { try!(write!(self.writer, ",")); }
 612         try!(escape_str(self.writer, name));
 613         try!(write!(self.writer, ":"));
 614         f(self)
 615     }
 616
 617     fn emit_tuple<F>(&mut self, len: usize, f: F) -> EncodeResult where
 618         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 619     {
 620         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 621         self.emit_seq(len, f)
 622     }
 623     fn emit_tuple_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult where
 624         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 625     {
 626         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 627         self.emit_seq_elt(idx, f)
 628     }
 629
 630     fn emit_tuple_struct<F>(&mut self, _name: &str, len: usize, f: F) -> EncodeResult where
 631         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 632     {
 633         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 634         self.emit_seq(len, f)
 635     }
 636     fn emit_tuple_struct_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult where
 637         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 638     {
 639         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 640         self.emit_seq_elt(idx, f)
 641     }
 642
 643     fn emit_option<F>(&mut self, f: F) -> EncodeResult where
 644         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 645     {
 646         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 647         f(self)
 648     }
 649     fn emit_option_none(&mut self) -> EncodeResult {
 650         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 651         self.emit_nil()
 652     }
 653     fn emit_option_some<F>(&mut self, f: F) -> EncodeResult where
 654         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 655     {
 656         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 657         f(self)
 658     }
 659
 660     fn emit_seq<F>(&mut self, _len: usize, f: F) -> EncodeResult where
 661         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 662     {
 663         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 664         try!(write!(self.writer, "["));
 665         try!(f(self));
 666         try!(write!(self.writer, "]"));
 667         Ok(())
 668     }
 669
 670     fn emit_seq_elt<F>(&mut self, idx: usize, f: F) -> EncodeResult where
 671         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 672     {
 673         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 674         if idx != 0 {
 675             try!(write!(self.writer, ","));
 676         }
 677         f(self)
 678     }
 679
 680     fn emit_map<F>(&mut self, _len: usize, f: F) -> EncodeResult where
 681         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 682     {
 683         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 684         try!(write!(self.writer, "{{"));
 685         try!(f(self));
 686         try!(write!(self.writer, "}}"));
 687         Ok(())
 688     }
 689
 690     fn emit_map_elt_key<F>(&mut self, idx: usize, f: F) -> EncodeResult where
 691         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 692     {
 693         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 694         if idx != 0 { try!(write!(self.writer, ",")) }
 695         self.is_emitting_map_key = true;
 696         try!(f(self));
 697         self.is_emitting_map_key = false;
 698         Ok(())
 699     }
 700
 701     fn emit_map_elt_val<F>(&mut self, _idx: usize, f: F) -> EncodeResult where
 702         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 703     {
 704         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 705         try!(write!(self.writer, ":"));
 706         f(self)
 707     }
 708 }
 709
 710 /// Another encoder for JSON, but prints out human-readable JSON instead of
 711 /// compact data
 712 pub struct PrettyEncoder<'a> {
 713     writer: &'a mut (fmt::Write+'a),
 714     curr_indent: usize,
 715     indent: usize,
 716     is_emitting_map_key: bool,
 717 }
 718
 719 impl<'a> PrettyEncoder<'a> {
 720     /// Creates a new encoder whose output will be written to the specified writer
 721     pub fn new(writer: &'a mut fmt::Write) -> PrettyEncoder<'a> {
 722         PrettyEncoder {
 723             writer: writer,
 724             curr_indent: 0,
 725             indent: 2,
 726             is_emitting_map_key: false,
 727         }
 728     }
 729
 730     /// Set the number of spaces to indent for each level.
 731     /// This is safe to set during encoding.
 732     pub fn set_indent(&mut self, indent: usize) {
 733         // self.indent very well could be 0 so we need to use checked division.
 734         let level = self.curr_indent.checked_div(self.indent).unwrap_or(0);
 735         self.indent = indent;
 736         self.curr_indent = level * self.indent;
 737     }
 738 }
 739
 740 impl<'a> ::Encoder for PrettyEncoder<'a> {
 741     type Error = EncoderError;
 742
 743     fn emit_nil(&mut self) -> EncodeResult {
 744         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 745         try!(write!(self.writer, "null"));
 746         Ok(())
 747     }
 748
 749     fn emit_uint(&mut self, v: usize) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 750     fn emit_u64(&mut self, v: u64) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 751     fn emit_u32(&mut self, v: u32) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 752     fn emit_u16(&mut self, v: u16) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 753     fn emit_u8(&mut self, v: u8) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 754
 755     fn emit_int(&mut self, v: isize) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 756     fn emit_i64(&mut self, v: i64) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 757     fn emit_i32(&mut self, v: i32) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 758     fn emit_i16(&mut self, v: i16) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 759     fn emit_i8(&mut self, v: i8) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 760
 761     fn emit_bool(&mut self, v: bool) -> EncodeResult {
 762         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 763         if v {
 764             try!(write!(self.writer, "true"));
 765         } else {
 766             try!(write!(self.writer, "false"));
 767         }
 768         Ok(())
 769     }
 770
 771     fn emit_f64(&mut self, v: f64) -> EncodeResult {
 772         emit_enquoted_if_mapkey!(self, fmt_number_or_null(v))
 773     }
 774     fn emit_f32(&mut self, v: f32) -> EncodeResult {
 775         self.emit_f64(v as f64)
 776     }
 777
 778     fn emit_char(&mut self, v: char) -> EncodeResult {
 779         escape_char(self.writer, v)
 780     }
 781     fn emit_str(&mut self, v: &str) -> EncodeResult {
 782         escape_str(self.writer, v)
 783     }
 784
 785     fn emit_enum<F>(&mut self, _name: &str, f: F) -> EncodeResult where
 786         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 787     {
 788         f(self)
 789     }
 790
 791     fn emit_enum_variant<F>(&mut self,
 792                             name: &str,
 793                             _id: usize,
 794                             cnt: usize,
 795                             f: F)
 796                             -> EncodeResult where
 797         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 798     {
 799         if cnt == 0 {
 800             escape_str(self.writer, name)
 801         } else {
 802             if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 803             try!(write!(self.writer, "{{\n"));
 804             self.curr_indent += self.indent;
 805             try!(spaces(self.writer, self.curr_indent));
 806             try!(write!(self.writer, "\"variant\": "));
 807             try!(escape_str(self.writer, name));
 808             try!(write!(self.writer, ",\n"));
 809             try!(spaces(self.writer, self.curr_indent));
 810             try!(write!(self.writer, "\"fields\": [\n"));
 811             self.curr_indent += self.indent;
 812             try!(f(self));
 813             self.curr_indent -= self.indent;
 814             try!(write!(self.writer, "\n"));
 815             try!(spaces(self.writer, self.curr_indent));
 816             self.curr_indent -= self.indent;
 817             try!(write!(self.writer, "]\n"));
 818             try!(spaces(self.writer, self.curr_indent));
 819             try!(write!(self.writer, "}}"));
 820             Ok(())
 821         }
 822     }
 823
 824     fn emit_enum_variant_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult where
 825         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 826     {
 827         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 828         if idx != 0 {
 829             try!(write!(self.writer, ",\n"));
 830         }
 831         try!(spaces(self.writer, self.curr_indent));
 832         f(self)
 833     }
 834
 835     fn emit_enum_struct_variant<F>(&mut self,
 836                                    name: &str,
 837                                    id: usize,
 838                                    cnt: usize,
 839                                    f: F) -> EncodeResult where
 840         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 841     {
 842         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 843         self.emit_enum_variant(name, id, cnt, f)
 844     }
 845
 846     fn emit_enum_struct_variant_field<F>(&mut self,
 847                                          _: &str,
 848                                          idx: usize,
 849                                          f: F) -> EncodeResult where
 850         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 851     {
 852         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 853         self.emit_enum_variant_arg(idx, f)
 854     }
 855
 856
 857     fn emit_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodeResult where
 858         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 859     {
 860         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 861         if len == 0 {
 862             try!(write!(self.writer, "{{}}"));
 863         } else {
 864             try!(write!(self.writer, "{{"));
 865             self.curr_indent += self.indent;
 866             try!(f(self));
 867             self.curr_indent -= self.indent;
 868             try!(write!(self.writer, "\n"));
 869             try!(spaces(self.writer, self.curr_indent));
 870             try!(write!(self.writer, "}}"));
 871         }
 872         Ok(())
 873     }
 874
 875     fn emit_struct_field<F>(&mut self, name: &str, idx: usize, f: F) -> EncodeResult where
 876         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 877     {
 878         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 879         if idx == 0 {
 880             try!(write!(self.writer, "\n"));
 881         } else {
 882             try!(write!(self.writer, ",\n"));
 883         }
 884         try!(spaces(self.writer, self.curr_indent));
 885         try!(escape_str(self.writer, name));
 886         try!(write!(self.writer, ": "));
 887         f(self)
 888     }
 889
 890     fn emit_tuple<F>(&mut self, len: usize, f: F) -> EncodeResult where
 891         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 892     {
 893         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 894         self.emit_seq(len, f)
 895     }
 896     fn emit_tuple_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult where
 897         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 898     {
 899         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 900         self.emit_seq_elt(idx, f)
 901     }
 902
 903     fn emit_tuple_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodeResult where
 904         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 905     {
 906         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 907         self.emit_seq(len, f)
 908     }
 909     fn emit_tuple_struct_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult where
 910         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 911     {
 912         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 913         self.emit_seq_elt(idx, f)
 914     }
 915
 916     fn emit_option<F>(&mut self, f: F) -> EncodeResult where
 917         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 918     {
 919         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 920         f(self)
 921     }
 922     fn emit_option_none(&mut self) -> EncodeResult {
 923         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 924         self.emit_nil()
 925     }
 926     fn emit_option_some<F>(&mut self, f: F) -> EncodeResult where
 927         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 928     {
 929         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 930         f(self)
 931     }
 932
 933     fn emit_seq<F>(&mut self, len: usize, f: F) -> EncodeResult where
 934         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 935     {
 936         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 937         if len == 0 {
 938             try!(write!(self.writer, "[]"));
 939         } else {
 940             try!(write!(self.writer, "["));
 941             self.curr_indent += self.indent;
 942             try!(f(self));
 943             self.curr_indent -= self.indent;
 944             try!(write!(self.writer, "\n"));
 945             try!(spaces(self.writer, self.curr_indent));
 946             try!(write!(self.writer, "]"));
 947         }
 948         Ok(())
 949     }
 950
 951     fn emit_seq_elt<F>(&mut self, idx: usize, f: F) -> EncodeResult where
 952         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 953     {
 954         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 955         if idx == 0 {
 956             try!(write!(self.writer, "\n"));
 957         } else {
 958             try!(write!(self.writer, ",\n"));
 959         }
 960         try!(spaces(self.writer, self.curr_indent));
 961         f(self)
 962     }
 963
 964     fn emit_map<F>(&mut self, len: usize, f: F) -> EncodeResult where
 965         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 966     {
 967         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 968         if len == 0 {
 969             try!(write!(self.writer, "{{}}"));
 970         } else {
 971             try!(write!(self.writer, "{{"));
 972             self.curr_indent += self.indent;
 973             try!(f(self));
 974             self.curr_indent -= self.indent;
 975             try!(write!(self.writer, "\n"));
 976             try!(spaces(self.writer, self.curr_indent));
 977             try!(write!(self.writer, "}}"));
 978         }
 979         Ok(())
 980     }
 981
 982     fn emit_map_elt_key<F>(&mut self, idx: usize, f: F) -> EncodeResult where
 983         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 984     {
 985         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 986         if idx == 0 {
 987             try!(write!(self.writer, "\n"));
 988         } else {
 989             try!(write!(self.writer, ",\n"));
 990         }
 991         try!(spaces(self.writer, self.curr_indent));
 992         self.is_emitting_map_key = true;
 993         try!(f(self));
 994         self.is_emitting_map_key = false;
 995         Ok(())
 996     }
 997
 998     fn emit_map_elt_val<F>(&mut self, _idx: usize, f: F) -> EncodeResult where
 999         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
1000     {
1001         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
1002         try!(write!(self.writer, ": "));
1003         f(self)
1004     }
1005 }
1006
1007 impl Encodable for Json {
1008     fn encode<E: ::Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
1009         match *self {
1010             Json::I64(v) => v.encode(e),
1011             Json::U64(v) => v.encode(e),
1012             Json::F64(v) => v.encode(e),
1013             Json::String(ref v) => v.encode(e),
1014             Json::Boolean(v) => v.encode(e),
1015             Json::Array(ref v) => v.encode(e),
1016             Json::Object(ref v) => v.encode(e),
1017             Json::Null => e.emit_nil(),
1018         }
1019     }
1020 }
1021
1022 /// Create an `AsJson` wrapper which can be used to print a value as JSON
1023 /// on-the-fly via `write!`
1024 pub fn as_json<T>(t: &T) -> AsJson<T> {
1025     AsJson { inner: t }
1026 }
1027
1028 /// Create an `AsPrettyJson` wrapper which can be used to print a value as JSON
1029 /// on-the-fly via `write!`
1030 pub fn as_pretty_json<T>(t: &T) -> AsPrettyJson<T> {
1031     AsPrettyJson { inner: t, indent: None }
1032 }
1033
1034 impl Json {
1035     /// Borrow this json object as a pretty object to generate a pretty
1036     /// representation for it via `Display`.
1037     pub fn pretty(&self) -> PrettyJson {
1038         PrettyJson { inner: self }
1039     }
1040
1041      /// If the Json value is an Object, returns the value associated with the provided key.
1042     /// Otherwise, returns None.
1043     pub fn find<'a>(&'a self, key: &str) -> Option<&'a Json>{
1044         match self {
1045             &Json::Object(ref map) => map.get(key),
1046             _ => None
1047         }
1048     }
1049
1050     /// Attempts to get a nested Json Object for each key in `keys`.
1051     /// If any key is found not to exist, find_path will return None.
1052     /// Otherwise, it will return the Json value associated with the final key.
1053     pub fn find_path<'a>(&'a self, keys: &[&str]) -> Option<&'a Json>{
1054         let mut target = self;
1055         for key in keys {
1056             match target.find(*key) {
1057                 Some(t) => { target = t; },
1058                 None => return None
1059             }
1060         }
1061         Some(target)
1062     }
1063
1064     /// If the Json value is an Object, performs a depth-first search until
1065     /// a value associated with the provided key is found. If no value is found
1066     /// or the Json value is not an Object, returns None.
1067     pub fn search<'a>(&'a self, key: &str) -> Option<&'a Json> {
1068         match self {
1069             &Json::Object(ref map) => {
1070                 match map.get(key) {
1071                     Some(json_value) => Some(json_value),
1072                     None => {
1073                         for (_, v) in map {
1074                             match v.search(key) {
1075                                 x if x.is_some() => return x,
1076                                 _ => ()
1077                             }
1078                         }
1079                         None
1080                     }
1081                 }
1082             },
1083             _ => None
1084         }
1085     }
1086
1087     /// Returns true if the Json value is an Object. Returns false otherwise.
1088     pub fn is_object<'a>(&'a self) -> bool {
1089         self.as_object().is_some()
1090     }
1091
1092     /// If the Json value is an Object, returns the associated BTreeMap.
1093     /// Returns None otherwise.
1094     pub fn as_object<'a>(&'a self) -> Option<&'a Object> {
1095         match self {
1096             &Json::Object(ref map) => Some(map),
1097             _ => None
1098         }
1099     }
1100
1101     /// Returns true if the Json value is an Array. Returns false otherwise.
1102     pub fn is_array<'a>(&'a self) -> bool {
1103         self.as_array().is_some()
1104     }
1105
1106     /// If the Json value is an Array, returns the associated vector.
1107     /// Returns None otherwise.
1108     pub fn as_array<'a>(&'a self) -> Option<&'a Array> {
1109         match self {
1110             &Json::Array(ref array) => Some(&*array),
1111             _ => None
1112         }
1113     }
1114
1115     /// Returns true if the Json value is a String. Returns false otherwise.
1116     pub fn is_string<'a>(&'a self) -> bool {
1117         self.as_string().is_some()
1118     }
1119
1120     /// If the Json value is a String, returns the associated str.
1121     /// Returns None otherwise.
1122     pub fn as_string<'a>(&'a self) -> Option<&'a str> {
1123         match *self {
1124             Json::String(ref s) => Some(&s[..]),
1125             _ => None
1126         }
1127     }
1128
1129     /// Returns true if the Json value is a Number. Returns false otherwise.
1130     pub fn is_number(&self) -> bool {
1131         match *self {
1132             Json::I64(_) | Json::U64(_) | Json::F64(_) => true,
1133             _ => false,
1134         }
1135     }
1136
1137     /// Returns true if the Json value is a i64. Returns false otherwise.
1138     pub fn is_i64(&self) -> bool {
1139         match *self {
1140             Json::I64(_) => true,
1141             _ => false,
1142         }
1143     }
1144
1145     /// Returns true if the Json value is a u64. Returns false otherwise.
1146     pub fn is_u64(&self) -> bool {
1147         match *self {
1148             Json::U64(_) => true,
1149             _ => false,
1150         }
1151     }
1152
1153     /// Returns true if the Json value is a f64. Returns false otherwise.
1154     pub fn is_f64(&self) -> bool {
1155         match *self {
1156             Json::F64(_) => true,
1157             _ => false,
1158         }
1159     }
1160
1161     /// If the Json value is a number, return or cast it to a i64.
1162     /// Returns None otherwise.
1163     pub fn as_i64(&self) -> Option<i64> {
1164         match *self {
1165             Json::I64(n) => Some(n),
1166             Json::U64(n) => Some(n as i64),
1167             _ => None
1168         }
1169     }
1170
1171     /// If the Json value is a number, return or cast it to a u64.
1172     /// Returns None otherwise.
1173     pub fn as_u64(&self) -> Option<u64> {
1174         match *self {
1175             Json::I64(n) => Some(n as u64),
1176             Json::U64(n) => Some(n),
1177             _ => None
1178         }
1179     }
1180
1181     /// If the Json value is a number, return or cast it to a f64.
1182     /// Returns None otherwise.
1183     pub fn as_f64(&self) -> Option<f64> {
1184         match *self {
1185             Json::I64(n) => Some(n as f64),
1186             Json::U64(n) => Some(n as f64),
1187             Json::F64(n) => Some(n),
1188             _ => None
1189         }
1190     }
1191
1192     /// Returns true if the Json value is a Boolean. Returns false otherwise.
1193     pub fn is_boolean(&self) -> bool {
1194         self.as_boolean().is_some()
1195     }
1196
1197     /// If the Json value is a Boolean, returns the associated bool.
1198     /// Returns None otherwise.
1199     pub fn as_boolean(&self) -> Option<bool> {
1200         match self {
1201             &Json::Boolean(b) => Some(b),
1202             _ => None
1203         }
1204     }
1205
1206     /// Returns true if the Json value is a Null. Returns false otherwise.
1207     pub fn is_null(&self) -> bool {
1208         self.as_null().is_some()
1209     }
1210
1211     /// If the Json value is a Null, returns ().
1212     /// Returns None otherwise.
1213     pub fn as_null(&self) -> Option<()> {
1214         match self {
1215             &Json::Null => Some(()),
1216             _ => None
1217         }
1218     }
1219 }
1220
1221 impl<'a> Index<&'a str>  for Json {
1222     type Output = Json;
1223
1224     fn index(&self, idx: &'a str) -> &Json {
1225         self.find(idx).unwrap()
1226     }
1227 }
1228
1229 impl Index<usize> for Json {
1230     type Output = Json;
1231
1232     fn index<'a>(&'a self, idx: usize) -> &'a Json {
1233         match self {
1234             &Json::Array(ref v) => &v[idx],
1235             _ => panic!("can only index Json with usize if it is an array")
1236         }
1237     }
1238 }
1239
1240 /// The output of the streaming parser.
1241 #[derive(PartialEq, Clone, Debug)]
1242 pub enum JsonEvent {
1243     ObjectStart,
1244     ObjectEnd,
1245     ArrayStart,
1246     ArrayEnd,
1247     BooleanValue(bool),
1248     I64Value(i64),
1249     U64Value(u64),
1250     F64Value(f64),
1251     StringValue(string::String),
1252     NullValue,
1253     Error(ParserError),
1254 }
1255
1256 #[derive(PartialEq, Debug)]
1257 enum ParserState {
1258     // Parse a value in an array, true means first element.
1259     ParseArray(bool),
1260     // Parse ',' or ']' after an element in an array.
1261     ParseArrayComma,
1262     // Parse a key:value in an object, true means first element.
1263     ParseObject(bool),
1264     // Parse ',' or ']' after an element in an object.
1265     ParseObjectComma,
1266     // Initial state.
1267     ParseStart,
1268     // Expecting the stream to end.
1269     ParseBeforeFinish,
1270     // Parsing can't continue.
1271     ParseFinished,
1272 }
1273
1274 /// A Stack represents the current position of the parser in the logical
1275 /// structure of the JSON stream.
1276 /// For example foo.bar[3].x
1277 pub struct Stack {
1278     stack: Vec<InternalStackElement>,
1279     str_buffer: Vec<u8>,
1280 }
1281
1282 /// StackElements compose a Stack.
1283 /// For example, StackElement::Key("foo"), StackElement::Key("bar"),
1284 /// StackElement::Index(3) and StackElement::Key("x") are the
1285 /// StackElements compositing the stack that represents foo.bar[3].x
1286 #[derive(PartialEq, Clone, Debug)]
1287 pub enum StackElement<'l> {
1288     Index(u32),
1289     Key(&'l str),
1290 }
1291
1292 // Internally, Key elements are stored as indices in a buffer to avoid
1293 // allocating a string for every member of an object.
1294 #[derive(PartialEq, Clone, Debug)]
1295 enum InternalStackElement {
1296     InternalIndex(u32),
1297     InternalKey(u16, u16), // start, size
1298 }
1299
1300 impl Stack {
1301     pub fn new() -> Stack {
1302         Stack { stack: Vec::new(), str_buffer: Vec::new() }
1303     }
1304
1305     /// Returns The number of elements in the Stack.
1306     pub fn len(&self) -> usize { self.stack.len() }
1307
1308     /// Returns true if the stack is empty.
1309     pub fn is_empty(&self) -> bool { self.stack.is_empty() }
1310
1311     /// Provides access to the StackElement at a given index.
1312     /// lower indices are at the bottom of the stack while higher indices are
1313     /// at the top.
1314     pub fn get<'l>(&'l self, idx: usize) -> StackElement<'l> {
1315         match self.stack[idx] {
1316             InternalIndex(i) => StackElement::Index(i),
1317             InternalKey(start, size) => {
1318                 StackElement::Key(str::from_utf8(
1319                     &self.str_buffer[start as usize .. start as usize + size as usize])
1320                         .unwrap())
1321             }
1322         }
1323     }
1324
1325     /// Compares this stack with an array of StackElements.
1326     pub fn is_equal_to(&self, rhs: &[StackElement]) -> bool {
1327         if self.stack.len() != rhs.len() { return false; }
1328         for i in 0..rhs.len() {
1329             if self.get(i) != rhs[i] { return false; }
1330         }
1331         return true;
1332     }
1333
1334     /// Returns true if the bottom-most elements of this stack are the same as
1335     /// the ones passed as parameter.
1336     pub fn starts_with(&self, rhs: &[StackElement]) -> bool {
1337         if self.stack.len() < rhs.len() { return false; }
1338         for i in 0..rhs.len() {
1339             if self.get(i) != rhs[i] { return false; }
1340         }
1341         return true;
1342     }
1343
1344     /// Returns true if the top-most elements of this stack are the same as
1345     /// the ones passed as parameter.
1346     pub fn ends_with(&self, rhs: &[StackElement]) -> bool {
1347         if self.stack.len() < rhs.len() { return false; }
1348         let offset = self.stack.len() - rhs.len();
1349         for i in 0..rhs.len() {
1350             if self.get(i + offset) != rhs[i] { return false; }
1351         }
1352         return true;
1353     }
1354
1355     /// Returns the top-most element (if any).
1356     pub fn top<'l>(&'l self) -> Option<StackElement<'l>> {
1357         return match self.stack.last() {
1358             None => None,
1359             Some(&InternalIndex(i)) => Some(StackElement::Index(i)),
1360             Some(&InternalKey(start, size)) => {
1361                 Some(StackElement::Key(str::from_utf8(
1362                     &self.str_buffer[start as usize .. (start+size) as usize]
1363                 ).unwrap()))
1364             }
1365         }
1366     }
1367
1368     // Used by Parser to insert StackElement::Key elements at the top of the stack.
1369     fn push_key(&mut self, key: string::String) {
1370         self.stack.push(InternalKey(self.str_buffer.len() as u16, key.len() as u16));
1371         for c in key.as_bytes() {
1372             self.str_buffer.push(*c);
1373         }
1374     }
1375
1376     // Used by Parser to insert StackElement::Index elements at the top of the stack.
1377     fn push_index(&mut self, index: u32) {
1378         self.stack.push(InternalIndex(index));
1379     }
1380
1381     // Used by Parser to remove the top-most element of the stack.
1382     fn pop(&mut self) {
1383         assert!(!self.is_empty());
1384         match *self.stack.last().unwrap() {
1385             InternalKey(_, sz) => {
1386                 let new_size = self.str_buffer.len() - sz as usize;
1387                 self.str_buffer.truncate(new_size);
1388             }
1389             InternalIndex(_) => {}
1390         }
1391         self.stack.pop();
1392     }
1393
1394     // Used by Parser to test whether the top-most element is an index.
1395     fn last_is_index(&self) -> bool {
1396         if self.is_empty() { return false; }
1397         return match *self.stack.last().unwrap() {
1398             InternalIndex(_) => true,
1399             _ => false,
1400         }
1401     }
1402
1403     // Used by Parser to increment the index of the top-most element.
1404     fn bump_index(&mut self) {
1405         let len = self.stack.len();
1406         let idx = match *self.stack.last().unwrap() {
1407             InternalIndex(i) => { i + 1 }
1408             _ => { panic!(); }
1409         };
1410         self.stack[len - 1] = InternalIndex(idx);
1411     }
1412 }
1413
1414 /// A streaming JSON parser implemented as an iterator of JsonEvent, consuming
1415 /// an iterator of char.
1416 pub struct Parser<T> {
1417     rdr: T,
1418     ch: Option<char>,
1419     line: usize,
1420     col: usize,
1421     // We maintain a stack representing where we are in the logical structure
1422     // of the JSON stream.
1423     stack: Stack,
1424     // A state machine is kept to make it possible to interrupt and resume parsing.
1425     state: ParserState,
1426 }
1427
1428 impl<T: Iterator<Item=char>> Iterator for Parser<T> {
1429     type Item = JsonEvent;
1430
1431     fn next(&mut self) -> Option<JsonEvent> {
1432         if self.state == ParseFinished {
1433             return None;
1434         }
1435
1436         if self.state == ParseBeforeFinish {
1437             self.parse_whitespace();
1438             // Make sure there is no trailing characters.
1439             if self.eof() {
1440                 self.state = ParseFinished;
1441                 return None;
1442             } else {
1443                 return Some(self.error_event(TrailingCharacters));
1444             }
1445         }
1446
1447         return Some(self.parse());
1448     }
1449 }
1450
1451 impl<T: Iterator<Item=char>> Parser<T> {
1452     /// Creates the JSON parser.
1453     pub fn new(rdr: T) -> Parser<T> {
1454         let mut p = Parser {
1455             rdr: rdr,
1456             ch: Some('\x00'),
1457             line: 1,
1458             col: 0,
1459             stack: Stack::new(),
1460             state: ParseStart,
1461         };
1462         p.bump();
1463         return p;
1464     }
1465
1466     /// Provides access to the current position in the logical structure of the
1467     /// JSON stream.
1468     pub fn stack<'l>(&'l self) -> &'l Stack {
1469         return &self.stack;
1470     }
1471
1472     fn eof(&self) -> bool { self.ch.is_none() }
1473     fn ch_or_null(&self) -> char { self.ch.unwrap_or('\x00') }
1474     fn bump(&mut self) {
1475         self.ch = self.rdr.next();
1476
1477         if self.ch_is('\n') {
1478             self.line += 1;
1479             self.col = 1;
1480         } else {
1481             self.col += 1;
1482         }
1483     }
1484
1485     fn next_char(&mut self) -> Option<char> {
1486         self.bump();
1487         self.ch
1488     }
1489     fn ch_is(&self, c: char) -> bool {
1490         self.ch == Some(c)
1491     }
1492
1493     fn error<U>(&self, reason: ErrorCode) -> Result<U, ParserError> {
1494         Err(SyntaxError(reason, self.line, self.col))
1495     }
1496
1497     fn parse_whitespace(&mut self) {
1498         while self.ch_is(' ') ||
1499               self.ch_is('\n') ||
1500               self.ch_is('\t') ||
1501               self.ch_is('\r') { self.bump(); }
1502     }
1503
1504     fn parse_number(&mut self) -> JsonEvent {
1505         let mut neg = false;
1506
1507         if self.ch_is('-') {
1508             self.bump();
1509             neg = true;
1510         }
1511
1512         let res = match self.parse_u64() {
1513             Ok(res) => res,
1514             Err(e) => { return Error(e); }
1515         };
1516
1517         if self.ch_is('.') || self.ch_is('e') || self.ch_is('E') {
1518             let mut res = res as f64;
1519
1520             if self.ch_is('.') {
1521                 res = match self.parse_decimal(res) {
1522                     Ok(res) => res,
1523                     Err(e) => { return Error(e); }
1524                 };
1525             }
1526
1527             if self.ch_is('e') || self.ch_is('E') {
1528                 res = match self.parse_exponent(res) {
1529                     Ok(res) => res,
1530                     Err(e) => { return Error(e); }
1531                 };
1532             }
1533
1534             if neg {
1535                 res *= -1.0;
1536             }
1537
1538             F64Value(res)
1539         } else {
1540             if neg {
1541                 let res = (res as i64).wrapping_neg();
1542
1543                 // Make sure we didn't underflow.
1544                 if res > 0 {
1545                     Error(SyntaxError(InvalidNumber, self.line, self.col))
1546                 } else {
1547                     I64Value(res)
1548                 }
1549             } else {
1550                 U64Value(res)
1551             }
1552         }
1553     }
1554
1555     #[allow(deprecated)] // possible resolve bug is mapping these to traits
1556     fn parse_u64(&mut self) -> Result<u64, ParserError> {
1557         let mut accum = 0u64;
1558         let last_accum = 0; // necessary to detect overflow.
1559
1560         match self.ch_or_null() {
1561             '0' => {
1562                 self.bump();
1563
1564                 // A leading '0' must be the only digit before the decimal point.
1565                 match self.ch_or_null() {
1566                     '0' ... '9' => return self.error(InvalidNumber),
1567                     _ => ()
1568                 }
1569             },
1570             '1' ... '9' => {
1571                 while !self.eof() {
1572                     match self.ch_or_null() {
1573                         c @ '0' ... '9' => {
1574                             accum = accum.wrapping_mul(10);
1575                             accum = accum.wrapping_add((c as u64) - ('0' as u64));
1576
1577                             // Detect overflow by comparing to the last value.
1578                             if accum <= last_accum { return self.error(InvalidNumber); }
1579
1580                             self.bump();
1581                         }
1582                         _ => break,
1583                     }
1584                 }
1585             }
1586             _ => return self.error(InvalidNumber),
1587         }
1588
1589         Ok(accum)
1590     }
1591
1592     fn parse_decimal(&mut self, mut res: f64) -> Result<f64, ParserError> {
1593         self.bump();
1594
1595         // Make sure a digit follows the decimal place.
1596         match self.ch_or_null() {
1597             '0' ... '9' => (),
1598              _ => return self.error(InvalidNumber)
1599         }
1600
1601         let mut dec = 1.0;
1602         while !self.eof() {
1603             match self.ch_or_null() {
1604                 c @ '0' ... '9' => {
1605                     dec /= 10.0;
1606                     res += (((c as isize) - ('0' as isize)) as f64) * dec;
1607                     self.bump();
1608                 }
1609                 _ => break,
1610             }
1611         }
1612
1613         Ok(res)
1614     }
1615
1616     fn parse_exponent(&mut self, mut res: f64) -> Result<f64, ParserError> {
1617         self.bump();
1618
1619         let mut exp = 0;
1620         let mut neg_exp = false;
1621
1622         if self.ch_is('+') {
1623             self.bump();
1624         } else if self.ch_is('-') {
1625             self.bump();
1626             neg_exp = true;
1627         }
1628
1629         // Make sure a digit follows the exponent place.
1630         match self.ch_or_null() {
1631             '0' ... '9' => (),
1632             _ => return self.error(InvalidNumber)
1633         }
1634         while !self.eof() {
1635             match self.ch_or_null() {
1636                 c @ '0' ... '9' => {
1637                     exp *= 10;
1638                     exp += (c as usize) - ('0' as usize);
1639
1640                     self.bump();
1641                 }
1642                 _ => break
1643             }
1644         }
1645
1646         let exp = 10_f64.powi(exp as i32);
1647         if neg_exp {
1648             res /= exp;
1649         } else {
1650             res *= exp;
1651         }
1652
1653         Ok(res)
1654     }
1655
1656     fn decode_hex_escape(&mut self) -> Result<u16, ParserError> {
1657         let mut i = 0;
1658         let mut n = 0;
1659         while i < 4 && !self.eof() {
1660             self.bump();
1661             n = match self.ch_or_null() {
1662                 c @ '0' ... '9' => n * 16 + ((c as u16) - ('0' as u16)),
1663                 'a' | 'A' => n * 16 + 10,
1664                 'b' | 'B' => n * 16 + 11,
1665                 'c' | 'C' => n * 16 + 12,
1666                 'd' | 'D' => n * 16 + 13,
1667                 'e' | 'E' => n * 16 + 14,
1668                 'f' | 'F' => n * 16 + 15,
1669                 _ => return self.error(InvalidEscape)
1670             };
1671
1672             i += 1;
1673         }
1674
1675         // Error out if we didn't parse 4 digits.
1676         if i != 4 {
1677             return self.error(InvalidEscape);
1678         }
1679
1680         Ok(n)
1681     }
1682
1683     fn parse_str(&mut self) -> Result<string::String, ParserError> {
1684         let mut escape = false;
1685         let mut res = string::String::new();
1686
1687         loop {
1688             self.bump();
1689             if self.eof() {
1690                 return self.error(EOFWhileParsingString);
1691             }
1692
1693             if escape {
1694                 match self.ch_or_null() {
1695                     '"' => res.push('"'),
1696                     '\\' => res.push('\\'),
1697                     '/' => res.push('/'),
1698                     'b' => res.push('\x08'),
1699                     'f' => res.push('\x0c'),
1700                     'n' => res.push('\n'),
1701                     'r' => res.push('\r'),
1702                     't' => res.push('\t'),
1703                     'u' => match try!(self.decode_hex_escape()) {
1704                         0xDC00 ... 0xDFFF => {
1705                             return self.error(LoneLeadingSurrogateInHexEscape)
1706                         }
1707
1708                         // Non-BMP characters are encoded as a sequence of
1709                         // two hex escapes, representing UTF-16 surrogates.
1710                         n1 @ 0xD800 ... 0xDBFF => {
1711                             match (self.next_char(), self.next_char()) {
1712                                 (Some('\\'), Some('u')) => (),
1713                                 _ => return self.error(UnexpectedEndOfHexEscape),
1714                             }
1715
1716                             let buf = [n1, try!(self.decode_hex_escape())];
1717                             match unicode_str::utf16_items(&buf).next() {
1718                                 Some(Utf16Item::ScalarValue(c)) => res.push(c),
1719                                 _ => return self.error(LoneLeadingSurrogateInHexEscape),
1720                             }
1721                         }
1722
1723                         n => match char::from_u32(n as u32) {
1724                             Some(c) => res.push(c),
1725                             None => return self.error(InvalidUnicodeCodePoint),
1726                         },
1727                     },
1728                     _ => return self.error(InvalidEscape),
1729                 }
1730                 escape = false;
1731             } else if self.ch_is('\\') {
1732                 escape = true;
1733             } else {
1734                 match self.ch {
1735                     Some('"') => {
1736                         self.bump();
1737                         return Ok(res);
1738                     },
1739                     Some(c) => res.push(c),
1740                     None => unreachable!()
1741                 }
1742             }
1743         }
1744     }
1745
1746     // Invoked at each iteration, consumes the stream until it has enough
1747     // information to return a JsonEvent.
1748     // Manages an internal state so that parsing can be interrupted and resumed.
1749     // Also keeps track of the position in the logical structure of the json
1750     // stream isize the form of a stack that can be queried by the user using the
1751     // stack() method.
1752     fn parse(&mut self) -> JsonEvent {
1753         loop {
1754             // The only paths where the loop can spin a new iteration
1755             // are in the cases ParseArrayComma and ParseObjectComma if ','
1756             // is parsed. In these cases the state is set to (respectively)
1757             // ParseArray(false) and ParseObject(false), which always return,
1758             // so there is no risk of getting stuck in an infinite loop.
1759             // All other paths return before the end of the loop's iteration.
1760             self.parse_whitespace();
1761
1762             match self.state {
1763                 ParseStart => {
1764                     return self.parse_start();
1765                 }
1766                 ParseArray(first) => {
1767                     return self.parse_array(first);
1768                 }
1769                 ParseArrayComma => {
1770                     match self.parse_array_comma_or_end() {
1771                         Some(evt) => { return evt; }
1772                         None => {}
1773                     }
1774                 }
1775                 ParseObject(first) => {
1776                     return self.parse_object(first);
1777                 }
1778                 ParseObjectComma => {
1779                     self.stack.pop();
1780                     if self.ch_is(',') {
1781                         self.state = ParseObject(false);
1782                         self.bump();
1783                     } else {
1784                         return self.parse_object_end();
1785                     }
1786                 }
1787                 _ => {
1788                     return self.error_event(InvalidSyntax);
1789                 }
1790             }
1791         }
1792     }
1793
1794     fn parse_start(&mut self) -> JsonEvent {
1795         let val = self.parse_value();
1796         self.state = match val {
1797             Error(_) => ParseFinished,
1798             ArrayStart => ParseArray(true),
1799             ObjectStart => ParseObject(true),
1800             _ => ParseBeforeFinish,
1801         };
1802         return val;
1803     }
1804
1805     fn parse_array(&mut self, first: bool) -> JsonEvent {
1806         if self.ch_is(']') {
1807             if !first {
1808                 self.error_event(InvalidSyntax)
1809             } else {
1810                 self.state = if self.stack.is_empty() {
1811                     ParseBeforeFinish
1812                 } else if self.stack.last_is_index() {
1813                     ParseArrayComma
1814                 } else {
1815                     ParseObjectComma
1816                 };
1817                 self.bump();
1818                 ArrayEnd
1819             }
1820         } else {
1821             if first {
1822                 self.stack.push_index(0);
1823             }
1824             let val = self.parse_value();
1825             self.state = match val {
1826                 Error(_) => ParseFinished,
1827                 ArrayStart => ParseArray(true),
1828                 ObjectStart => ParseObject(true),
1829                 _ => ParseArrayComma,
1830             };
1831             val
1832         }
1833     }
1834
1835     fn parse_array_comma_or_end(&mut self) -> Option<JsonEvent> {
1836         if self.ch_is(',') {
1837             self.stack.bump_index();
1838             self.state = ParseArray(false);
1839             self.bump();
1840             None
1841         } else if self.ch_is(']') {
1842             self.stack.pop();
1843             self.state = if self.stack.is_empty() {
1844                 ParseBeforeFinish
1845             } else if self.stack.last_is_index() {
1846                 ParseArrayComma
1847             } else {
1848                 ParseObjectComma
1849             };
1850             self.bump();
1851             Some(ArrayEnd)
1852         } else if self.eof() {
1853             Some(self.error_event(EOFWhileParsingArray))
1854         } else {
1855             Some(self.error_event(InvalidSyntax))
1856         }
1857     }
1858
1859     fn parse_object(&mut self, first: bool) -> JsonEvent {
1860         if self.ch_is('}') {
1861             if !first {
1862                 if self.stack.is_empty() {
1863                     return self.error_event(TrailingComma);
1864                 } else {
1865                     self.stack.pop();
1866                 }
1867             }
1868             self.state = if self.stack.is_empty() {
1869                 ParseBeforeFinish
1870             } else if self.stack.last_is_index() {
1871                 ParseArrayComma
1872             } else {
1873                 ParseObjectComma
1874             };
1875             self.bump();
1876             return ObjectEnd;
1877         }
1878         if self.eof() {
1879             return self.error_event(EOFWhileParsingObject);
1880         }
1881         if !self.ch_is('"') {
1882             return self.error_event(KeyMustBeAString);
1883         }
1884         let s = match self.parse_str() {
1885             Ok(s) => s,
1886             Err(e) => {
1887                 self.state = ParseFinished;
1888                 return Error(e);
1889             }
1890         };
1891         self.parse_whitespace();
1892         if self.eof() {
1893             return self.error_event(EOFWhileParsingObject);
1894         } else if self.ch_or_null() != ':' {
1895             return self.error_event(ExpectedColon);
1896         }
1897         self.stack.push_key(s);
1898         self.bump();
1899         self.parse_whitespace();
1900
1901         let val = self.parse_value();
1902
1903         self.state = match val {
1904             Error(_) => ParseFinished,
1905             ArrayStart => ParseArray(true),
1906             ObjectStart => ParseObject(true),
1907             _ => ParseObjectComma,
1908         };
1909         return val;
1910     }
1911
1912     fn parse_object_end(&mut self) -> JsonEvent {
1913         if self.ch_is('}') {
1914             self.state = if self.stack.is_empty() {
1915                 ParseBeforeFinish
1916             } else if self.stack.last_is_index() {
1917                 ParseArrayComma
1918             } else {
1919                 ParseObjectComma
1920             };
1921             self.bump();
1922             ObjectEnd
1923         } else if self.eof() {
1924             self.error_event(EOFWhileParsingObject)
1925         } else {
1926             self.error_event(InvalidSyntax)
1927         }
1928     }
1929
1930     fn parse_value(&mut self) -> JsonEvent {
1931         if self.eof() { return self.error_event(EOFWhileParsingValue); }
1932         match self.ch_or_null() {
1933             'n' => { self.parse_ident("ull", NullValue) }
1934             't' => { self.parse_ident("rue", BooleanValue(true)) }
1935             'f' => { self.parse_ident("alse", BooleanValue(false)) }
1936             '0' ... '9' | '-' => self.parse_number(),
1937             '"' => match self.parse_str() {
1938                 Ok(s) => StringValue(s),
1939                 Err(e) => Error(e),
1940             },
1941             '[' => {
1942                 self.bump();
1943                 ArrayStart
1944             }
1945             '{' => {
1946                 self.bump();
1947                 ObjectStart
1948             }
1949             _ => { self.error_event(InvalidSyntax) }
1950         }
1951     }
1952
1953     fn parse_ident(&mut self, ident: &str, value: JsonEvent) -> JsonEvent {
1954         if ident.chars().all(|c| Some(c) == self.next_char()) {
1955             self.bump();
1956             value
1957         } else {
1958             Error(SyntaxError(InvalidSyntax, self.line, self.col))
1959         }
1960     }
1961
1962     fn error_event(&mut self, reason: ErrorCode) -> JsonEvent {
1963         self.state = ParseFinished;
1964         Error(SyntaxError(reason, self.line, self.col))
1965     }
1966 }
1967
1968 /// A Builder consumes a json::Parser to create a generic Json structure.
1969 pub struct Builder<T> {
1970     parser: Parser<T>,
1971     token: Option<JsonEvent>,
1972 }
1973
1974 impl<T: Iterator<Item=char>> Builder<T> {
1975     /// Create a JSON Builder.
1976     pub fn new(src: T) -> Builder<T> {
1977         Builder { parser: Parser::new(src), token: None, }
1978     }
1979
1980     // Decode a Json value from a Parser.
1981     pub fn build(&mut self) -> Result<Json, BuilderError> {
1982         self.bump();
1983         let result = self.build_value();
1984         self.bump();
1985         match self.token {
1986             None => {}
1987             Some(Error(ref e)) => { return Err(e.clone()); }
1988             ref tok => { panic!("unexpected token {:?}", tok.clone()); }
1989         }
1990         result
1991     }
1992
1993     fn bump(&mut self) {
1994         self.token = self.parser.next();
1995     }
1996
1997     fn build_value(&mut self) -> Result<Json, BuilderError> {
1998         return match self.token {
1999             Some(NullValue) => Ok(Json::Null),
2000             Some(I64Value(n)) => Ok(Json::I64(n)),
2001             Some(U64Value(n)) => Ok(Json::U64(n)),
2002             Some(F64Value(n)) => Ok(Json::F64(n)),
2003             Some(BooleanValue(b)) => Ok(Json::Boolean(b)),
2004             Some(StringValue(ref mut s)) => {
2005                 let mut temp = string::String::new();
2006                 swap(s, &mut temp);
2007                 Ok(Json::String(temp))
2008             }
2009             Some(Error(ref e)) => Err(e.clone()),
2010             Some(ArrayStart) => self.build_array(),
2011             Some(ObjectStart) => self.build_object(),
2012             Some(ObjectEnd) => self.parser.error(InvalidSyntax),
2013             Some(ArrayEnd) => self.parser.error(InvalidSyntax),
2014             None => self.parser.error(EOFWhileParsingValue),
2015         }
2016     }
2017
2018     fn build_array(&mut self) -> Result<Json, BuilderError> {
2019         self.bump();
2020         let mut values = Vec::new();
2021
2022         loop {
2023             if self.token == Some(ArrayEnd) {
2024                 return Ok(Json::Array(values.into_iter().collect()));
2025             }
2026             match self.build_value() {
2027                 Ok(v) => values.push(v),
2028                 Err(e) => { return Err(e) }
2029             }
2030             self.bump();
2031         }
2032     }
2033
2034     fn build_object(&mut self) -> Result<Json, BuilderError> {
2035         self.bump();
2036
2037         let mut values = BTreeMap::new();
2038
2039         loop {
2040             match self.token {
2041                 Some(ObjectEnd) => { return Ok(Json::Object(values)); }
2042                 Some(Error(ref e)) => { return Err(e.clone()); }
2043                 None => { break; }
2044                 _ => {}
2045             }
2046             let key = match self.parser.stack().top() {
2047                 Some(StackElement::Key(k)) => { k.to_string() }
2048                 _ => { panic!("invalid state"); }
2049             };
2050             match self.build_value() {
2051                 Ok(value) => { values.insert(key, value); }
2052                 Err(e) => { return Err(e); }
2053             }
2054             self.bump();
2055         }
2056         return self.parser.error(EOFWhileParsingObject);
2057     }
2058 }
2059
2060 /// Decodes a json value from an `&mut io::Read`
2061 pub fn from_reader(rdr: &mut Read) -> Result<Json, BuilderError> {
2062     let mut contents = Vec::new();
2063     match rdr.read_to_end(&mut contents) {
2064         Ok(c)  => c,
2065         Err(e) => return Err(io_error_to_error(e))
2066     };
2067     let s = match str::from_utf8(&contents).ok() {
2068         Some(s) => s,
2069         _       => return Err(SyntaxError(NotUtf8, 0, 0))
2070     };
2071     let mut builder = Builder::new(s.chars());
2072     builder.build()
2073 }
2074
2075 /// Decodes a json value from a string
2076 pub fn from_str(s: &str) -> Result<Json, BuilderError> {
2077     let mut builder = Builder::new(s.chars());
2078     builder.build()
2079 }
2080
2081 /// A structure to decode JSON to values in rust.
2082 pub struct Decoder {
2083     stack: Vec<Json>,
2084 }
2085
2086 impl Decoder {
2087     /// Creates a new decoder instance for decoding the specified JSON value.
2088     pub fn new(json: Json) -> Decoder {
2089         Decoder { stack: vec![json] }
2090     }
2091 }
2092
2093 impl Decoder {
2094     fn pop(&mut self) -> Json {
2095         self.stack.pop().unwrap()
2096     }
2097 }
2098
2099 macro_rules! expect {
2100     ($e:expr, Null) => ({
2101         match $e {
2102             Json::Null => Ok(()),
2103             other => Err(ExpectedError("Null".to_string(),
2104                                        format!("{}", other)))
2105         }
2106     });
2107     ($e:expr, $t:ident) => ({
2108         match $e {
2109             Json::$t(v) => Ok(v),
2110             other => {
2111                 Err(ExpectedError(stringify!($t).to_string(),
2112                                   format!("{}", other)))
2113             }
2114         }
2115     })
2116 }
2117
2118 macro_rules! read_primitive {
2119     ($name:ident, $ty:ty) => {
2120         fn $name(&mut self) -> DecodeResult<$ty> {
2121             match self.pop() {
2122                 Json::I64(f) => Ok(f as $ty),
2123                 Json::U64(f) => Ok(f as $ty),
2124                 Json::F64(f) => Err(ExpectedError("Integer".to_string(), format!("{}", f))),
2125                 // re: #12967.. a type w/ numeric keys (ie HashMap<usize, V> etc)
2126                 // is going to have a string here, as per JSON spec.
2127                 Json::String(s) => match s.parse().ok() {
2128                     Some(f) => Ok(f),
2129                     None => Err(ExpectedError("Number".to_string(), s)),
2130                 },
2131                 value => Err(ExpectedError("Number".to_string(), format!("{}", value))),
2132             }
2133         }
2134     }
2135 }
2136
2137 impl ::Decoder for Decoder {
2138     type Error = DecoderError;
2139
2140     fn read_nil(&mut self) -> DecodeResult<()> {
2141         expect!(self.pop(), Null)
2142     }
2143
2144     read_primitive! { read_uint, usize }
2145     read_primitive! { read_u8, u8 }
2146     read_primitive! { read_u16, u16 }
2147     read_primitive! { read_u32, u32 }
2148     read_primitive! { read_u64, u64 }
2149     read_primitive! { read_int, isize }
2150     read_primitive! { read_i8, i8 }
2151     read_primitive! { read_i16, i16 }
2152     read_primitive! { read_i32, i32 }
2153     read_primitive! { read_i64, i64 }
2154
2155     fn read_f32(&mut self) -> DecodeResult<f32> { self.read_f64().map(|x| x as f32) }
2156
2157     fn read_f64(&mut self) -> DecodeResult<f64> {
2158         match self.pop() {
2159             Json::I64(f) => Ok(f as f64),
2160             Json::U64(f) => Ok(f as f64),
2161             Json::F64(f) => Ok(f),
2162             Json::String(s) => {
2163                 // re: #12967.. a type w/ numeric keys (ie HashMap<usize, V> etc)
2164                 // is going to have a string here, as per JSON spec.
2165                 match s.parse().ok() {
2166                     Some(f) => Ok(f),
2167                     None => Err(ExpectedError("Number".to_string(), s)),
2168                 }
2169             },
2170             Json::Null => Ok(f64::NAN),
2171             value => Err(ExpectedError("Number".to_string(), format!("{}", value)))
2172         }
2173     }
2174
2175     fn read_bool(&mut self) -> DecodeResult<bool> {
2176         expect!(self.pop(), Boolean)
2177     }
2178
2179     fn read_char(&mut self) -> DecodeResult<char> {
2180         let s = try!(self.read_str());
2181         {
2182             let mut it = s.chars();
2183             match (it.next(), it.next()) {
2184                 // exactly one character
2185                 (Some(c), None) => return Ok(c),
2186                 _ => ()
2187             }
2188         }
2189         Err(ExpectedError("single character string".to_string(), format!("{}", s)))
2190     }
2191
2192     fn read_str(&mut self) -> DecodeResult<string::String> {
2193         expect!(self.pop(), String)
2194     }
2195
2196     fn read_enum<T, F>(&mut self, _name: &str, f: F) -> DecodeResult<T> where
2197         F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2198     {
2199         f(self)
2200     }
2201
2202     fn read_enum_variant<T, F>(&mut self, names: &[&str],
2203                                mut f: F) -> DecodeResult<T>
2204         where F: FnMut(&mut Decoder, usize) -> DecodeResult<T>,
2205     {
2206         let name = match self.pop() {
2207             Json::String(s) => s,
2208             Json::Object(mut o) => {
2209                 let n = match o.remove(&"variant".to_string()) {
2210                     Some(Json::String(s)) => s,
2211                     Some(val) => {
2212                         return Err(ExpectedError("String".to_string(), format!("{}", val)))
2213                     }
2214                     None => {
2215                         return Err(MissingFieldError("variant".to_string()))
2216                     }
2217                 };
2218                 match o.remove(&"fields".to_string()) {
2219                     Some(Json::Array(l)) => {
2220                         for field in l.into_iter().rev() {
2221                             self.stack.push(field);
2222                         }
2223                     },
2224                     Some(val) => {
2225                         return Err(ExpectedError("Array".to_string(), format!("{}", val)))
2226                     }
2227                     None => {
2228                         return Err(MissingFieldError("fields".to_string()))
2229                     }
2230                 }
2231                 n
2232             }
2233             json => {
2234                 return Err(ExpectedError("String or Object".to_string(), format!("{}", json)))
2235             }
2236         };
2237         let idx = match names.iter().position(|n| *n == &name[..]) {
2238             Some(idx) => idx,
2239             None => return Err(UnknownVariantError(name))
2240         };
2241         f(self, idx)
2242     }
2243
2244     fn read_enum_variant_arg<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
2245         F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2246     {
2247         f(self)
2248     }
2249
2250     fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> DecodeResult<T> where
2251         F: FnMut(&mut Decoder, usize) -> DecodeResult<T>,
2252     {
2253         self.read_enum_variant(names, f)
2254     }
2255
2256
2257     fn read_enum_struct_variant_field<T, F>(&mut self,
2258                                          _name: &str,
2259                                          idx: usize,
2260                                          f: F)
2261                                          -> DecodeResult<T> where
2262         F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2263     {
2264         self.read_enum_variant_arg(idx, f)
2265     }
2266
2267     fn read_struct<T, F>(&mut self, _name: &str, _len: usize, f: F) -> DecodeResult<T> where
2268         F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2269     {
2270         let value = try!(f(self));
2271         self.pop();
2272         Ok(value)
2273     }
2274
2275     fn read_struct_field<T, F>(&mut self,
2276                                name: &str,
2277                                _idx: usize,
2278                                f: F)
2279                                -> DecodeResult<T> where
2280         F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2281     {
2282         let mut obj = try!(expect!(self.pop(), Object));
2283
2284         let value = match obj.remove(&name.to_string()) {
2285             None => {
2286                 // Add a Null and try to parse it as an Option<_>
2287                 // to get None as a default value.
2288                 self.stack.push(Json::Null);
2289                 match f(self) {
2290                     Ok(x) => x,
2291                     Err(_) => return Err(MissingFieldError(name.to_string())),
2292                 }
2293             },
2294             Some(json) => {
2295                 self.stack.push(json);
2296                 try!(f(self))
2297             }
2298         };
2299         self.stack.push(Json::Object(obj));
2300         Ok(value)
2301     }
2302
2303     fn read_tuple<T, F>(&mut self, tuple_len: usize, f: F) -> DecodeResult<T> where
2304         F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2305     {
2306         self.read_seq(move |d, len| {
2307             if len == tuple_len {
2308                 f(d)
2309             } else {
2310                 Err(ExpectedError(format!("Tuple{}", tuple_len), format!("Tuple{}", len)))
2311             }
2312         })
2313     }
2314
2315     fn read_tuple_arg<T, F>(&mut self, idx: usize, f: F) -> DecodeResult<T> where
2316         F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2317     {
2318         self.read_seq_elt(idx, f)
2319     }
2320
2321     fn read_tuple_struct<T, F>(&mut self,
2322                                _name: &str,
2323                                len: usize,
2324                                f: F)
2325                                -> DecodeResult<T> where
2326         F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2327     {
2328         self.read_tuple(len, f)
2329     }
2330
2331     fn read_tuple_struct_arg<T, F>(&mut self,
2332                                    idx: usize,
2333                                    f: F)
2334                                    -> DecodeResult<T> where
2335         F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2336     {
2337         self.read_tuple_arg(idx, f)
2338     }
2339
2340     fn read_option<T, F>(&mut self, mut f: F) -> DecodeResult<T> where
2341         F: FnMut(&mut Decoder, bool) -> DecodeResult<T>,
2342     {
2343         match self.pop() {
2344             Json::Null => f(self, false),
2345             value => { self.stack.push(value); f(self, true) }
2346         }
2347     }
2348
2349     fn read_seq<T, F>(&mut self, f: F) -> DecodeResult<T> where
2350         F: FnOnce(&mut Decoder, usize) -> DecodeResult<T>,
2351     {
2352         let array = try!(expect!(self.pop(), Array));
2353         let len = array.len();
2354         for v in array.into_iter().rev() {
2355             self.stack.push(v);
2356         }
2357         f(self, len)
2358     }
2359
2360     fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
2361         F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2362     {
2363         f(self)
2364     }
2365
2366     fn read_map<T, F>(&mut self, f: F) -> DecodeResult<T> where
2367         F: FnOnce(&mut Decoder, usize) -> DecodeResult<T>,
2368     {
2369         let obj = try!(expect!(self.pop(), Object));
2370         let len = obj.len();
2371         for (key, value) in obj {
2372             self.stack.push(value);
2373             self.stack.push(Json::String(key));
2374         }
2375         f(self, len)
2376     }
2377
2378     fn read_map_elt_key<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
2379        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2380     {
2381         f(self)
2382     }
2383
2384     fn read_map_elt_val<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
2385        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2386     {
2387         f(self)
2388     }
2389
2390     fn error(&mut self, err: &str) -> DecoderError {
2391         ApplicationError(err.to_string())
2392     }
2393 }
2394
2395 /// A trait for converting values to JSON
2396 pub trait ToJson {
2397     /// Converts the value of `self` to an instance of JSON
2398     fn to_json(&self) -> Json;
2399 }
2400
2401 macro_rules! to_json_impl_i64 {
2402     ($($t:ty), +) => (
2403         $(impl ToJson for $t {
2404             fn to_json(&self) -> Json {
2405                 Json::I64(*self as i64)
2406             }
2407         })+
2408     )
2409 }
2410
2411 to_json_impl_i64! { isize, i8, i16, i32, i64 }
2412
2413 macro_rules! to_json_impl_u64 {
2414     ($($t:ty), +) => (
2415         $(impl ToJson for $t {
2416             fn to_json(&self) -> Json {
2417                 Json::U64(*self as u64)
2418             }
2419         })+
2420     )
2421 }
2422
2423 to_json_impl_u64! { usize, u8, u16, u32, u64 }
2424
2425 impl ToJson for Json {
2426     fn to_json(&self) -> Json { self.clone() }
2427 }
2428
2429 impl ToJson for f32 {
2430     fn to_json(&self) -> Json { (*self as f64).to_json() }
2431 }
2432
2433 impl ToJson for f64 {
2434     fn to_json(&self) -> Json {
2435         match self.classify() {
2436             Fp::Nan | Fp::Infinite => Json::Null,
2437             _                  => Json::F64(*self)
2438         }
2439     }
2440 }
2441
2442 impl ToJson for () {
2443     fn to_json(&self) -> Json { Json::Null }
2444 }
2445
2446 impl ToJson for bool {
2447     fn to_json(&self) -> Json { Json::Boolean(*self) }
2448 }
2449
2450 impl ToJson for str {
2451     fn to_json(&self) -> Json { Json::String(self.to_string()) }
2452 }
2453
2454 impl ToJson for string::String {
2455     fn to_json(&self) -> Json { Json::String((*self).clone()) }
2456 }
2457
2458 macro_rules! tuple_impl {
2459     // use variables to indicate the arity of the tuple
2460     ($($tyvar:ident),* ) => {
2461         // the trailing commas are for the 1 tuple
2462         impl<
2463             $( $tyvar : ToJson ),*
2464             > ToJson for ( $( $tyvar ),* , ) {
2465
2466             #[inline]
2467             #[allow(non_snake_case)]
2468             fn to_json(&self) -> Json {
2469                 match *self {
2470                     ($(ref $tyvar),*,) => Json::Array(vec![$($tyvar.to_json()),*])
2471                 }
2472             }
2473         }
2474     }
2475 }
2476
2477 tuple_impl!{A}
2478 tuple_impl!{A, B}
2479 tuple_impl!{A, B, C}
2480 tuple_impl!{A, B, C, D}
2481 tuple_impl!{A, B, C, D, E}
2482 tuple_impl!{A, B, C, D, E, F}
2483 tuple_impl!{A, B, C, D, E, F, G}
2484 tuple_impl!{A, B, C, D, E, F, G, H}
2485 tuple_impl!{A, B, C, D, E, F, G, H, I}
2486 tuple_impl!{A, B, C, D, E, F, G, H, I, J}
2487 tuple_impl!{A, B, C, D, E, F, G, H, I, J, K}
2488 tuple_impl!{A, B, C, D, E, F, G, H, I, J, K, L}
2489
2490 impl<A: ToJson> ToJson for [A] {
2491     fn to_json(&self) -> Json { Json::Array(self.iter().map(|elt| elt.to_json()).collect()) }
2492 }
2493
2494 impl<A: ToJson> ToJson for Vec<A> {
2495     fn to_json(&self) -> Json { Json::Array(self.iter().map(|elt| elt.to_json()).collect()) }
2496 }
2497
2498 impl<A: ToJson> ToJson for BTreeMap<string::String, A> {
2499     fn to_json(&self) -> Json {
2500         let mut d = BTreeMap::new();
2501         for (key, value) in self {
2502             d.insert((*key).clone(), value.to_json());
2503         }
2504         Json::Object(d)
2505     }
2506 }
2507
2508 impl<A: ToJson> ToJson for HashMap<string::String, A> {
2509     fn to_json(&self) -> Json {
2510         let mut d = BTreeMap::new();
2511         for (key, value) in self {
2512             d.insert((*key).clone(), value.to_json());
2513         }
2514         Json::Object(d)
2515     }
2516 }
2517
2518 impl<A:ToJson> ToJson for Option<A> {
2519     fn to_json(&self) -> Json {
2520         match *self {
2521             None => Json::Null,
2522             Some(ref value) => value.to_json()
2523         }
2524     }
2525 }
2526
2527 struct FormatShim<'a, 'b: 'a> {
2528     inner: &'a mut fmt::Formatter<'b>,
2529 }
2530
2531 impl<'a, 'b> fmt::Write for FormatShim<'a, 'b> {
2532     fn write_str(&mut self, s: &str) -> fmt::Result {
2533         match self.inner.write_str(s) {
2534             Ok(_) => Ok(()),
2535             Err(_) => Err(fmt::Error)
2536         }
2537     }
2538 }
2539
2540 impl fmt::Display for Json {
2541     /// Encodes a json value into a string
2542     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2543         let mut shim = FormatShim { inner: f };
2544         let mut encoder = Encoder::new(&mut shim);
2545         match self.encode(&mut encoder) {
2546             Ok(_) => Ok(()),
2547             Err(_) => Err(fmt::Error)
2548         }
2549     }
2550 }
2551
2552 impl<'a> fmt::Display for PrettyJson<'a> {
2553     /// Encodes a json value into a string
2554     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2555         let mut shim = FormatShim { inner: f };
2556         let mut encoder = PrettyEncoder::new(&mut shim);
2557         match self.inner.encode(&mut encoder) {
2558             Ok(_) => Ok(()),
2559             Err(_) => Err(fmt::Error)
2560         }
2561     }
2562 }
2563
2564 impl<'a, T: Encodable> fmt::Display for AsJson<'a, T> {
2565     /// Encodes a json value into a string
2566     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2567         let mut shim = FormatShim { inner: f };
2568         let mut encoder = Encoder::new(&mut shim);
2569         match self.inner.encode(&mut encoder) {
2570             Ok(_) => Ok(()),
2571             Err(_) => Err(fmt::Error)
2572         }
2573     }
2574 }
2575
2576 impl<'a, T> AsPrettyJson<'a, T> {
2577     /// Set the indentation level for the emitted JSON
2578     pub fn indent(mut self, indent: usize) -> AsPrettyJson<'a, T> {
2579         self.indent = Some(indent);
2580         self
2581     }
2582 }
2583
2584 impl<'a, T: Encodable> fmt::Display for AsPrettyJson<'a, T> {
2585     /// Encodes a json value into a string
2586     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2587         let mut shim = FormatShim { inner: f };
2588         let mut encoder = PrettyEncoder::new(&mut shim);
2589         match self.indent {
2590             Some(n) => encoder.set_indent(n),
2591             None => {}
2592         }
2593         match self.inner.encode(&mut encoder) {
2594             Ok(_) => Ok(()),
2595             Err(_) => Err(fmt::Error)
2596         }
2597     }
2598 }
2599
2600 impl FromStr for Json {
2601     type Err = BuilderError;
2602     fn from_str(s: &str) -> Result<Json, BuilderError> {
2603         from_str(s)
2604     }
2605 }
2606
2607 #[cfg(test)]
2608 mod tests {
2609     extern crate test;
2610     use self::Animal::*;
2611     use self::DecodeEnum::*;
2612     use self::test::Bencher;
2613     use {Encodable, Decodable};
2614     use super::Json::*;
2615     use super::ErrorCode::*;
2616     use super::ParserError::*;
2617     use super::DecoderError::*;
2618     use super::JsonEvent::*;
2619     use super::{Json, from_str, DecodeResult, DecoderError, JsonEvent, Parser,
2620                 StackElement, Stack, Decoder, Encoder, EncoderError};
2621     use std::{i64, u64, f32, f64};
2622     use std::io::prelude::*;
2623     use std::collections::BTreeMap;
2624     use std::string;
2625
2626     #[derive(RustcDecodable, Eq, PartialEq, Debug)]
2627     struct OptionData {
2628         opt: Option<usize>,
2629     }
2630
2631     #[test]
2632     fn test_decode_option_none() {
2633         let s ="{}";
2634         let obj: OptionData = super::decode(s).unwrap();
2635         assert_eq!(obj, OptionData { opt: None });
2636     }
2637
2638     #[test]
2639     fn test_decode_option_some() {
2640         let s = "{ \"opt\": 10 }";
2641         let obj: OptionData = super::decode(s).unwrap();
2642         assert_eq!(obj, OptionData { opt: Some(10) });
2643     }
2644
2645     #[test]
2646     fn test_decode_option_malformed() {
2647         check_err::<OptionData>("{ \"opt\": [] }",
2648                                 ExpectedError("Number".to_string(), "[]".to_string()));
2649         check_err::<OptionData>("{ \"opt\": false }",
2650                                 ExpectedError("Number".to_string(), "false".to_string()));
2651     }
2652
2653     #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
2654     enum Animal {
2655         Dog,
2656         Frog(string::String, isize)
2657     }
2658
2659     #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
2660     struct Inner {
2661         a: (),
2662         b: usize,
2663         c: Vec<string::String>,
2664     }
2665
2666     #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
2667     struct Outer {
2668         inner: Vec<Inner>,
2669     }
2670
2671     fn mk_object(items: &[(string::String, Json)]) -> Json {
2672         let mut d = BTreeMap::new();
2673
2674         for item in items {
2675             match *item {
2676                 (ref key, ref value) => { d.insert((*key).clone(), (*value).clone()); },
2677             }
2678         };
2679
2680         Object(d)
2681     }
2682
2683     #[test]
2684     fn test_from_str_trait() {
2685         let s = "null";
2686         assert!(s.parse::<Json>().unwrap() == s.parse().unwrap());
2687     }
2688
2689     #[test]
2690     fn test_write_null() {
2691         assert_eq!(Null.to_string(), "null");
2692         assert_eq!(Null.pretty().to_string(), "null");
2693     }
2694
2695     #[test]
2696     fn test_write_i64() {
2697         assert_eq!(U64(0).to_string(), "0");
2698         assert_eq!(U64(0).pretty().to_string(), "0");
2699
2700         assert_eq!(U64(1234).to_string(), "1234");
2701         assert_eq!(U64(1234).pretty().to_string(), "1234");
2702
2703         assert_eq!(I64(-5678).to_string(), "-5678");
2704         assert_eq!(I64(-5678).pretty().to_string(), "-5678");
2705
2706         assert_eq!(U64(7650007200025252000).to_string(), "7650007200025252000");
2707         assert_eq!(U64(7650007200025252000).pretty().to_string(), "7650007200025252000");
2708     }
2709
2710     #[test]
2711     fn test_write_f64() {
2712         assert_eq!(F64(3.0).to_string(), "3.0");
2713         assert_eq!(F64(3.0).pretty().to_string(), "3.0");
2714
2715         assert_eq!(F64(3.1).to_string(), "3.1");
2716         assert_eq!(F64(3.1).pretty().to_string(), "3.1");
2717
2718         assert_eq!(F64(-1.5).to_string(), "-1.5");
2719         assert_eq!(F64(-1.5).pretty().to_string(), "-1.5");
2720
2721         assert_eq!(F64(0.5).to_string(), "0.5");
2722         assert_eq!(F64(0.5).pretty().to_string(), "0.5");
2723
2724         assert_eq!(F64(f64::NAN).to_string(), "null");
2725         assert_eq!(F64(f64::NAN).pretty().to_string(), "null");
2726
2727         assert_eq!(F64(f64::INFINITY).to_string(), "null");
2728         assert_eq!(F64(f64::INFINITY).pretty().to_string(), "null");
2729
2730         assert_eq!(F64(f64::NEG_INFINITY).to_string(), "null");
2731         assert_eq!(F64(f64::NEG_INFINITY).pretty().to_string(), "null");
2732     }
2733
2734     #[test]
2735     fn test_write_str() {
2736         assert_eq!(String("".to_string()).to_string(), "\"\"");
2737         assert_eq!(String("".to_string()).pretty().to_string(), "\"\"");
2738
2739         assert_eq!(String("homura".to_string()).to_string(), "\"homura\"");
2740         assert_eq!(String("madoka".to_string()).pretty().to_string(), "\"madoka\"");
2741     }
2742
2743     #[test]
2744     fn test_write_bool() {
2745         assert_eq!(Boolean(true).to_string(), "true");
2746         assert_eq!(Boolean(true).pretty().to_string(), "true");
2747
2748         assert_eq!(Boolean(false).to_string(), "false");
2749         assert_eq!(Boolean(false).pretty().to_string(), "false");
2750     }
2751
2752     #[test]
2753     fn test_write_array() {
2754         assert_eq!(Array(vec![]).to_string(), "[]");
2755         assert_eq!(Array(vec![]).pretty().to_string(), "[]");
2756
2757         assert_eq!(Array(vec![Boolean(true)]).to_string(), "[true]");
2758         assert_eq!(
2759             Array(vec![Boolean(true)]).pretty().to_string(),
2760             "\
2761             [\n  \
2762                 true\n\
2763             ]"
2764         );
2765
2766         let long_test_array = Array(vec![
2767             Boolean(false),
2768             Null,
2769             Array(vec![String("foo\nbar".to_string()), F64(3.5)])]);
2770
2771         assert_eq!(long_test_array.to_string(),
2772             "[false,null,[\"foo\\nbar\",3.5]]");
2773         assert_eq!(
2774             long_test_array.pretty().to_string(),
2775             "\
2776             [\n  \
2777                 false,\n  \
2778                 null,\n  \
2779                 [\n    \
2780                     \"foo\\nbar\",\n    \
2781                     3.5\n  \
2782                 ]\n\
2783             ]"
2784         );
2785     }
2786
2787     #[test]
2788     fn test_write_object() {
2789         assert_eq!(mk_object(&[]).to_string(), "{}");
2790         assert_eq!(mk_object(&[]).pretty().to_string(), "{}");
2791
2792         assert_eq!(
2793             mk_object(&[
2794                 ("a".to_string(), Boolean(true))
2795             ]).to_string(),
2796             "{\"a\":true}"
2797         );
2798         assert_eq!(
2799             mk_object(&[("a".to_string(), Boolean(true))]).pretty().to_string(),
2800             "\
2801             {\n  \
2802                 \"a\": true\n\
2803             }"
2804         );
2805
2806         let complex_obj = mk_object(&[
2807                 ("b".to_string(), Array(vec![
2808                     mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
2809                     mk_object(&[("d".to_string(), String("".to_string()))])
2810                 ]))
2811             ]);
2812
2813         assert_eq!(
2814             complex_obj.to_string(),
2815             "{\
2816                 \"b\":[\
2817                     {\"c\":\"\\f\\r\"},\
2818                     {\"d\":\"\"}\
2819                 ]\
2820             }"
2821         );
2822         assert_eq!(
2823             complex_obj.pretty().to_string(),
2824             "\
2825             {\n  \
2826                 \"b\": [\n    \
2827                     {\n      \
2828                         \"c\": \"\\f\\r\"\n    \
2829                     },\n    \
2830                     {\n      \
2831                         \"d\": \"\"\n    \
2832                     }\n  \
2833                 ]\n\
2834             }"
2835         );
2836
2837         let a = mk_object(&[
2838             ("a".to_string(), Boolean(true)),
2839             ("b".to_string(), Array(vec![
2840                 mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
2841                 mk_object(&[("d".to_string(), String("".to_string()))])
2842             ]))
2843         ]);
2844
2845         // We can't compare the strings directly because the object fields be
2846         // printed in a different order.
2847         assert_eq!(a.clone(), a.to_string().parse().unwrap());
2848         assert_eq!(a.clone(), a.pretty().to_string().parse().unwrap());
2849     }
2850
2851     #[test]
2852     fn test_write_enum() {
2853         let animal = Dog;
2854         assert_eq!(
2855             format!("{}", super::as_json(&animal)),
2856             "\"Dog\""
2857         );
2858         assert_eq!(
2859             format!("{}", super::as_pretty_json(&animal)),
2860             "\"Dog\""
2861         );
2862
2863         let animal = Frog("Henry".to_string(), 349);
2864         assert_eq!(
2865             format!("{}", super::as_json(&animal)),
2866             "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"
2867         );
2868         assert_eq!(
2869             format!("{}", super::as_pretty_json(&animal)),
2870             "{\n  \
2871                \"variant\": \"Frog\",\n  \
2872                \"fields\": [\n    \
2873                  \"Henry\",\n    \
2874                  349\n  \
2875                ]\n\
2876              }"
2877         );
2878     }
2879
2880     macro_rules! check_encoder_for_simple {
2881         ($value:expr, $expected:expr) => ({
2882             let s = format!("{}", super::as_json(&$value));
2883             assert_eq!(s, $expected);
2884
2885             let s = format!("{}", super::as_pretty_json(&$value));
2886             assert_eq!(s, $expected);
2887         })
2888     }
2889
2890     #[test]
2891     fn test_write_some() {
2892         check_encoder_for_simple!(Some("jodhpurs".to_string()), "\"jodhpurs\"");
2893     }
2894
2895     #[test]
2896     fn test_write_none() {
2897         check_encoder_for_simple!(None::<string::String>, "null");
2898     }
2899
2900     #[test]
2901     fn test_write_char() {
2902         check_encoder_for_simple!('a', "\"a\"");
2903         check_encoder_for_simple!('\t', "\"\\t\"");
2904         check_encoder_for_simple!('\u{0000}', "\"\\u0000\"");
2905         check_encoder_for_simple!('\u{001b}', "\"\\u001b\"");
2906         check_encoder_for_simple!('\u{007f}', "\"\\u007f\"");
2907         check_encoder_for_simple!('\u{00a0}', "\"\u{00a0}\"");
2908         check_encoder_for_simple!('\u{abcd}', "\"\u{abcd}\"");
2909         check_encoder_for_simple!('\u{10ffff}', "\"\u{10ffff}\"");
2910     }
2911
2912     #[test]
2913     fn test_trailing_characters() {
2914         assert_eq!(from_str("nulla"),  Err(SyntaxError(TrailingCharacters, 1, 5)));
2915         assert_eq!(from_str("truea"),  Err(SyntaxError(TrailingCharacters, 1, 5)));
2916         assert_eq!(from_str("falsea"), Err(SyntaxError(TrailingCharacters, 1, 6)));
2917         assert_eq!(from_str("1a"),     Err(SyntaxError(TrailingCharacters, 1, 2)));
2918         assert_eq!(from_str("[]a"),    Err(SyntaxError(TrailingCharacters, 1, 3)));
2919         assert_eq!(from_str("{}a"),    Err(SyntaxError(TrailingCharacters, 1, 3)));
2920     }
2921
2922     #[test]
2923     fn test_read_identifiers() {
2924         assert_eq!(from_str("n"),    Err(SyntaxError(InvalidSyntax, 1, 2)));
2925         assert_eq!(from_str("nul"),  Err(SyntaxError(InvalidSyntax, 1, 4)));
2926         assert_eq!(from_str("t"),    Err(SyntaxError(InvalidSyntax, 1, 2)));
2927         assert_eq!(from_str("truz"), Err(SyntaxError(InvalidSyntax, 1, 4)));
2928         assert_eq!(from_str("f"),    Err(SyntaxError(InvalidSyntax, 1, 2)));
2929         assert_eq!(from_str("faz"),  Err(SyntaxError(InvalidSyntax, 1, 3)));
2930
2931         assert_eq!(from_str("null"), Ok(Null));
2932         assert_eq!(from_str("true"), Ok(Boolean(true)));
2933         assert_eq!(from_str("false"), Ok(Boolean(false)));
2934         assert_eq!(from_str(" null "), Ok(Null));
2935         assert_eq!(from_str(" true "), Ok(Boolean(true)));
2936         assert_eq!(from_str(" false "), Ok(Boolean(false)));
2937     }
2938
2939     #[test]
2940     fn test_decode_identifiers() {
2941         let v: () = super::decode("null").unwrap();
2942         assert_eq!(v, ());
2943
2944         let v: bool = super::decode("true").unwrap();
2945         assert_eq!(v, true);
2946
2947         let v: bool = super::decode("false").unwrap();
2948         assert_eq!(v, false);
2949     }
2950
2951     #[test]
2952     fn test_read_number() {
2953         assert_eq!(from_str("+"),   Err(SyntaxError(InvalidSyntax, 1, 1)));
2954         assert_eq!(from_str("."),   Err(SyntaxError(InvalidSyntax, 1, 1)));
2955         assert_eq!(from_str("NaN"), Err(SyntaxError(InvalidSyntax, 1, 1)));
2956         assert_eq!(from_str("-"),   Err(SyntaxError(InvalidNumber, 1, 2)));
2957         assert_eq!(from_str("00"),  Err(SyntaxError(InvalidNumber, 1, 2)));
2958         assert_eq!(from_str("1."),  Err(SyntaxError(InvalidNumber, 1, 3)));
2959         assert_eq!(from_str("1e"),  Err(SyntaxError(InvalidNumber, 1, 3)));
2960         assert_eq!(from_str("1e+"), Err(SyntaxError(InvalidNumber, 1, 4)));
2961
2962         assert_eq!(from_str("18446744073709551616"), Err(SyntaxError(InvalidNumber, 1, 20)));
2963         assert_eq!(from_str("-9223372036854775809"), Err(SyntaxError(InvalidNumber, 1, 21)));
2964
2965         assert_eq!(from_str("3"), Ok(U64(3)));
2966         assert_eq!(from_str("3.1"), Ok(F64(3.1)));
2967         assert_eq!(from_str("-1.2"), Ok(F64(-1.2)));
2968         assert_eq!(from_str("0.4"), Ok(F64(0.4)));
2969         assert_eq!(from_str("0.4e5"), Ok(F64(0.4e5)));
2970         assert_eq!(from_str("0.4e+15"), Ok(F64(0.4e15)));
2971         assert_eq!(from_str("0.4e-01"), Ok(F64(0.4e-01)));
2972         assert_eq!(from_str(" 3 "), Ok(U64(3)));
2973
2974         assert_eq!(from_str("-9223372036854775808"), Ok(I64(i64::MIN)));
2975         assert_eq!(from_str("9223372036854775807"), Ok(U64(i64::MAX as u64)));
2976         assert_eq!(from_str("18446744073709551615"), Ok(U64(u64::MAX)));
2977     }
2978
2979     #[test]
2980     fn test_decode_numbers() {
2981         let v: f64 = super::decode("3").unwrap();
2982         assert_eq!(v, 3.0);
2983
2984         let v: f64 = super::decode("3.1").unwrap();
2985         assert_eq!(v, 3.1);
2986
2987         let v: f64 = super::decode("-1.2").unwrap();
2988         assert_eq!(v, -1.2);
2989
2990         let v: f64 = super::decode("0.4").unwrap();
2991         assert_eq!(v, 0.4);
2992
2993         let v: f64 = super::decode("0.4e5").unwrap();
2994         assert_eq!(v, 0.4e5);
2995
2996         let v: f64 = super::decode("0.4e15").unwrap();
2997         assert_eq!(v, 0.4e15);
2998
2999         let v: f64 = super::decode("0.4e-01").unwrap();
3000         assert_eq!(v, 0.4e-01);
3001
3002         let v: u64 = super::decode("0").unwrap();
3003         assert_eq!(v, 0);
3004
3005         let v: u64 = super::decode("18446744073709551615").unwrap();
3006         assert_eq!(v, u64::MAX);
3007
3008         let v: i64 = super::decode("-9223372036854775808").unwrap();
3009         assert_eq!(v, i64::MIN);
3010
3011         let v: i64 = super::decode("9223372036854775807").unwrap();
3012         assert_eq!(v, i64::MAX);
3013
3014         let res: DecodeResult<i64> = super::decode("765.25");
3015         assert_eq!(res, Err(ExpectedError("Integer".to_string(),
3016                                           "765.25".to_string())));
3017     }
3018
3019     #[test]
3020     fn test_read_str() {
3021         assert_eq!(from_str("\""),    Err(SyntaxError(EOFWhileParsingString, 1, 2)));
3022         assert_eq!(from_str("\"lol"), Err(SyntaxError(EOFWhileParsingString, 1, 5)));
3023
3024         assert_eq!(from_str("\"\""), Ok(String("".to_string())));
3025         assert_eq!(from_str("\"foo\""), Ok(String("foo".to_string())));
3026         assert_eq!(from_str("\"\\\"\""), Ok(String("\"".to_string())));
3027         assert_eq!(from_str("\"\\b\""), Ok(String("\x08".to_string())));
3028         assert_eq!(from_str("\"\\n\""), Ok(String("\n".to_string())));
3029         assert_eq!(from_str("\"\\r\""), Ok(String("\r".to_string())));
3030         assert_eq!(from_str("\"\\t\""), Ok(String("\t".to_string())));
3031         assert_eq!(from_str(" \"foo\" "), Ok(String("foo".to_string())));
3032         assert_eq!(from_str("\"\\u12ab\""), Ok(String("\u{12ab}".to_string())));
3033         assert_eq!(from_str("\"\\uAB12\""), Ok(String("\u{AB12}".to_string())));
3034     }
3035
3036     #[test]
3037     fn test_decode_str() {
3038         let s = [("\"\"", ""),
3039                  ("\"foo\"", "foo"),
3040                  ("\"\\\"\"", "\""),
3041                  ("\"\\b\"", "\x08"),
3042                  ("\"\\n\"", "\n"),
3043                  ("\"\\r\"", "\r"),
3044                  ("\"\\t\"", "\t"),
3045                  ("\"\\u12ab\"", "\u{12ab}"),
3046                  ("\"\\uAB12\"", "\u{AB12}")];
3047
3048         for &(i, o) in &s {
3049             let v: string::String = super::decode(i).unwrap();
3050             assert_eq!(v, o);
3051         }
3052     }
3053
3054     #[test]
3055     fn test_read_array() {
3056         assert_eq!(from_str("["),     Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
3057         assert_eq!(from_str("[1"),    Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
3058         assert_eq!(from_str("[1,"),   Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
3059         assert_eq!(from_str("[1,]"),  Err(SyntaxError(InvalidSyntax,        1, 4)));
3060         assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax,        1, 4)));
3061
3062         assert_eq!(from_str("[]"), Ok(Array(vec![])));
3063         assert_eq!(from_str("[ ]"), Ok(Array(vec![])));
3064         assert_eq!(from_str("[true]"), Ok(Array(vec![Boolean(true)])));
3065         assert_eq!(from_str("[ false ]"), Ok(Array(vec![Boolean(false)])));
3066         assert_eq!(from_str("[null]"), Ok(Array(vec![Null])));
3067         assert_eq!(from_str("[3, 1]"),
3068                      Ok(Array(vec![U64(3), U64(1)])));
3069         assert_eq!(from_str("\n[3, 2]\n"),
3070                      Ok(Array(vec![U64(3), U64(2)])));
3071         assert_eq!(from_str("[2, [4, 1]]"),
3072                Ok(Array(vec![U64(2), Array(vec![U64(4), U64(1)])])));
3073     }
3074
3075     #[test]
3076     fn test_decode_array() {
3077         let v: Vec<()> = super::decode("[]").unwrap();
3078         assert_eq!(v, []);
3079
3080         let v: Vec<()> = super::decode("[null]").unwrap();
3081         assert_eq!(v, [()]);
3082
3083         let v: Vec<bool> = super::decode("[true]").unwrap();
3084         assert_eq!(v, [true]);
3085
3086         let v: Vec<isize> = super::decode("[3, 1]").unwrap();
3087         assert_eq!(v, [3, 1]);
3088
3089         let v: Vec<Vec<usize>> = super::decode("[[3], [1, 2]]").unwrap();
3090         assert_eq!(v, [vec![3], vec![1, 2]]);
3091     }
3092
3093     #[test]
3094     fn test_decode_tuple() {
3095         let t: (usize, usize, usize) = super::decode("[1, 2, 3]").unwrap();
3096         assert_eq!(t, (1, 2, 3));
3097
3098         let t: (usize, string::String) = super::decode("[1, \"two\"]").unwrap();
3099         assert_eq!(t, (1, "two".to_string()));
3100     }
3101
3102     #[test]
3103     fn test_decode_tuple_malformed_types() {
3104         assert!(super::decode::<(usize, string::String)>("[1, 2]").is_err());
3105     }
3106
3107     #[test]
3108     fn test_decode_tuple_malformed_length() {
3109         assert!(super::decode::<(usize, usize)>("[1, 2, 3]").is_err());
3110     }
3111
3112     #[test]
3113     fn test_read_object() {
3114         assert_eq!(from_str("{"),       Err(SyntaxError(EOFWhileParsingObject, 1, 2)));
3115         assert_eq!(from_str("{ "),      Err(SyntaxError(EOFWhileParsingObject, 1, 3)));
3116         assert_eq!(from_str("{1"),      Err(SyntaxError(KeyMustBeAString,      1, 2)));
3117         assert_eq!(from_str("{ \"a\""), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
3118         assert_eq!(from_str("{\"a\""),  Err(SyntaxError(EOFWhileParsingObject, 1, 5)));
3119         assert_eq!(from_str("{\"a\" "), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
3120
3121         assert_eq!(from_str("{\"a\" 1"),   Err(SyntaxError(ExpectedColon,         1, 6)));
3122         assert_eq!(from_str("{\"a\":"),    Err(SyntaxError(EOFWhileParsingValue,  1, 6)));
3123         assert_eq!(from_str("{\"a\":1"),   Err(SyntaxError(EOFWhileParsingObject, 1, 7)));
3124         assert_eq!(from_str("{\"a\":1 1"), Err(SyntaxError(InvalidSyntax,         1, 8)));
3125         assert_eq!(from_str("{\"a\":1,"),  Err(SyntaxError(EOFWhileParsingObject, 1, 8)));
3126
3127         assert_eq!(from_str("{}").unwrap(), mk_object(&[]));
3128         assert_eq!(from_str("{\"a\": 3}").unwrap(),
3129                   mk_object(&[("a".to_string(), U64(3))]));
3130
3131         assert_eq!(from_str(
3132                       "{ \"a\": null, \"b\" : true }").unwrap(),
3133                   mk_object(&[
3134                       ("a".to_string(), Null),
3135                       ("b".to_string(), Boolean(true))]));
3136         assert_eq!(from_str("\n{ \"a\": null, \"b\" : true }\n").unwrap(),
3137                   mk_object(&[
3138                       ("a".to_string(), Null),
3139                       ("b".to_string(), Boolean(true))]));
3140         assert_eq!(from_str(
3141                       "{\"a\" : 1.0 ,\"b\": [ true ]}").unwrap(),
3142                   mk_object(&[
3143                       ("a".to_string(), F64(1.0)),
3144                       ("b".to_string(), Array(vec![Boolean(true)]))
3145                   ]));
3146         assert_eq!(from_str(
3147                       "{\
3148                           \"a\": 1.0, \
3149                           \"b\": [\
3150                               true,\
3151                               \"foo\\nbar\", \
3152                               { \"c\": {\"d\": null} } \
3153                           ]\
3154                       }").unwrap(),
3155                   mk_object(&[
3156                       ("a".to_string(), F64(1.0)),
3157                       ("b".to_string(), Array(vec![
3158                           Boolean(true),
3159                           String("foo\nbar".to_string()),
3160                           mk_object(&[
3161                               ("c".to_string(), mk_object(&[("d".to_string(), Null)]))
3162                           ])
3163                       ]))
3164                   ]));
3165     }
3166
3167     #[test]
3168     fn test_decode_struct() {
3169         let s = "{
3170             \"inner\": [
3171                 { \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] }
3172             ]
3173         }";
3174
3175         let v: Outer = super::decode(s).unwrap();
3176         assert_eq!(
3177             v,
3178             Outer {
3179                 inner: vec![
3180                     Inner { a: (), b: 2, c: vec!["abc".to_string(), "xyz".to_string()] }
3181                 ]
3182             }
3183         );
3184     }
3185
3186     #[derive(RustcDecodable)]
3187     struct FloatStruct {
3188         f: f64,
3189         a: Vec<f64>
3190     }
3191     #[test]
3192     fn test_decode_struct_with_nan() {
3193         let s = "{\"f\":null,\"a\":[null,123]}";
3194         let obj: FloatStruct = super::decode(s).unwrap();
3195         assert!(obj.f.is_nan());
3196         assert!(obj.a[0].is_nan());
3197         assert_eq!(obj.a[1], 123f64);
3198     }
3199
3200     #[test]
3201     fn test_decode_option() {
3202         let value: Option<string::String> = super::decode("null").unwrap();
3203         assert_eq!(value, None);
3204
3205         let value: Option<string::String> = super::decode("\"jodhpurs\"").unwrap();
3206         assert_eq!(value, Some("jodhpurs".to_string()));
3207     }
3208
3209     #[test]
3210     fn test_decode_enum() {
3211         let value: Animal = super::decode("\"Dog\"").unwrap();
3212         assert_eq!(value, Dog);
3213
3214         let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}";
3215         let value: Animal = super::decode(s).unwrap();
3216         assert_eq!(value, Frog("Henry".to_string(), 349));
3217     }
3218
3219     #[test]
3220     fn test_decode_map() {
3221         let s = "{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\
3222                   \"fields\":[\"Henry\", 349]}}";
3223         let mut map: BTreeMap<string::String, Animal> = super::decode(s).unwrap();
3224
3225         assert_eq!(map.remove(&"a".to_string()), Some(Dog));
3226         assert_eq!(map.remove(&"b".to_string()), Some(Frog("Henry".to_string(), 349)));
3227     }
3228
3229     #[test]
3230     fn test_multiline_errors() {
3231         assert_eq!(from_str("{\n  \"foo\":\n \"bar\""),
3232             Err(SyntaxError(EOFWhileParsingObject, 3, 8)));
3233     }
3234
3235     #[derive(RustcDecodable)]
3236     #[allow(dead_code)]
3237     struct DecodeStruct {
3238         x: f64,
3239         y: bool,
3240         z: string::String,
3241         w: Vec<DecodeStruct>
3242     }
3243     #[derive(RustcDecodable)]
3244     enum DecodeEnum {
3245         A(f64),
3246         B(string::String)
3247     }
3248     fn check_err<T: Decodable>(to_parse: &'static str, expected: DecoderError) {
3249         let res: DecodeResult<T> = match from_str(to_parse) {
3250             Err(e) => Err(ParseError(e)),
3251             Ok(json) => Decodable::decode(&mut Decoder::new(json))
3252         };
3253         match res {
3254             Ok(_) => panic!("`{:?}` parsed & decoded ok, expecting error `{:?}`",
3255                               to_parse, expected),
3256             Err(ParseError(e)) => panic!("`{:?}` is not valid json: {:?}",
3257                                            to_parse, e),
3258             Err(e) => {
3259                 assert_eq!(e, expected);
3260             }
3261         }
3262     }
3263     #[test]
3264     fn test_decode_errors_struct() {
3265         check_err::<DecodeStruct>("[]", ExpectedError("Object".to_string(), "[]".to_string()));
3266         check_err::<DecodeStruct>("{\"x\": true, \"y\": true, \"z\": \"\", \"w\": []}",
3267                                   ExpectedError("Number".to_string(), "true".to_string()));
3268         check_err::<DecodeStruct>("{\"x\": 1, \"y\": [], \"z\": \"\", \"w\": []}",
3269                                   ExpectedError("Boolean".to_string(), "[]".to_string()));
3270         check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": {}, \"w\": []}",
3271                                   ExpectedError("String".to_string(), "{}".to_string()));
3272         check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\", \"w\": null}",
3273                                   ExpectedError("Array".to_string(), "null".to_string()));
3274         check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\"}",
3275                                   MissingFieldError("w".to_string()));
3276     }
3277     #[test]
3278     fn test_decode_errors_enum() {
3279         check_err::<DecodeEnum>("{}",
3280                                 MissingFieldError("variant".to_string()));
3281         check_err::<DecodeEnum>("{\"variant\": 1}",
3282                                 ExpectedError("String".to_string(), "1".to_string()));
3283         check_err::<DecodeEnum>("{\"variant\": \"A\"}",
3284                                 MissingFieldError("fields".to_string()));
3285         check_err::<DecodeEnum>("{\"variant\": \"A\", \"fields\": null}",
3286                                 ExpectedError("Array".to_string(), "null".to_string()));
3287         check_err::<DecodeEnum>("{\"variant\": \"C\", \"fields\": []}",
3288                                 UnknownVariantError("C".to_string()));
3289     }
3290
3291     #[test]
3292     fn test_find(){
3293         let json_value = from_str("{\"dog\" : \"cat\"}").unwrap();
3294         let found_str = json_value.find("dog");
3295         assert!(found_str.unwrap().as_string().unwrap() == "cat");
3296     }
3297
3298     #[test]
3299     fn test_find_path(){
3300         let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap();
3301         let found_str = json_value.find_path(&["dog", "cat", "mouse"]);
3302         assert!(found_str.unwrap().as_string().unwrap() == "cheese");
3303     }
3304
3305     #[test]
3306     fn test_search(){
3307         let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap();
3308         let found_str = json_value.search("mouse").and_then(|j| j.as_string());
3309         assert!(found_str.unwrap() == "cheese");
3310     }
3311
3312     #[test]
3313     fn test_index(){
3314         let json_value = from_str("{\"animals\":[\"dog\",\"cat\",\"mouse\"]}").unwrap();
3315         let ref array = json_value["animals"];
3316         assert_eq!(array[0].as_string().unwrap(), "dog");
3317         assert_eq!(array[1].as_string().unwrap(), "cat");
3318         assert_eq!(array[2].as_string().unwrap(), "mouse");
3319     }
3320
3321     #[test]
3322     fn test_is_object(){
3323         let json_value = from_str("{}").unwrap();
3324         assert!(json_value.is_object());
3325     }
3326
3327     #[test]
3328     fn test_as_object(){
3329         let json_value = from_str("{}").unwrap();
3330         let json_object = json_value.as_object();
3331         assert!(json_object.is_some());
3332     }
3333
3334     #[test]
3335     fn test_is_array(){
3336         let json_value = from_str("[1, 2, 3]").unwrap();
3337         assert!(json_value.is_array());
3338     }
3339
3340     #[test]
3341     fn test_as_array(){
3342         let json_value = from_str("[1, 2, 3]").unwrap();
3343         let json_array = json_value.as_array();
3344         let expected_length = 3;
3345         assert!(json_array.is_some() && json_array.unwrap().len() == expected_length);
3346     }
3347
3348     #[test]
3349     fn test_is_string(){
3350         let json_value = from_str("\"dog\"").unwrap();
3351         assert!(json_value.is_string());
3352     }
3353
3354     #[test]
3355     fn test_as_string(){
3356         let json_value = from_str("\"dog\"").unwrap();
3357         let json_str = json_value.as_string();
3358         let expected_str = "dog";
3359         assert_eq!(json_str, Some(expected_str));
3360     }
3361
3362     #[test]
3363     fn test_is_number(){
3364         let json_value = from_str("12").unwrap();
3365         assert!(json_value.is_number());
3366     }
3367
3368     #[test]
3369     fn test_is_i64(){
3370         let json_value = from_str("-12").unwrap();
3371         assert!(json_value.is_i64());
3372
3373         let json_value = from_str("12").unwrap();
3374         assert!(!json_value.is_i64());
3375
3376         let json_value = from_str("12.0").unwrap();
3377         assert!(!json_value.is_i64());
3378     }
3379
3380     #[test]
3381     fn test_is_u64(){
3382         let json_value = from_str("12").unwrap();
3383         assert!(json_value.is_u64());
3384
3385         let json_value = from_str("-12").unwrap();
3386         assert!(!json_value.is_u64());
3387
3388         let json_value = from_str("12.0").unwrap();
3389         assert!(!json_value.is_u64());
3390     }
3391
3392     #[test]
3393     fn test_is_f64(){
3394         let json_value = from_str("12").unwrap();
3395         assert!(!json_value.is_f64());
3396
3397         let json_value = from_str("-12").unwrap();
3398         assert!(!json_value.is_f64());
3399
3400         let json_value = from_str("12.0").unwrap();
3401         assert!(json_value.is_f64());
3402
3403         let json_value = from_str("-12.0").unwrap();
3404         assert!(json_value.is_f64());
3405     }
3406
3407     #[test]
3408     fn test_as_i64(){
3409         let json_value = from_str("-12").unwrap();
3410         let json_num = json_value.as_i64();
3411         assert_eq!(json_num, Some(-12));
3412     }
3413
3414     #[test]
3415     fn test_as_u64(){
3416         let json_value = from_str("12").unwrap();
3417         let json_num = json_value.as_u64();
3418         assert_eq!(json_num, Some(12));
3419     }
3420
3421     #[test]
3422     fn test_as_f64(){
3423         let json_value = from_str("12.0").unwrap();
3424         let json_num = json_value.as_f64();
3425         assert_eq!(json_num, Some(12f64));
3426     }
3427
3428     #[test]
3429     fn test_is_boolean(){
3430         let json_value = from_str("false").unwrap();
3431         assert!(json_value.is_boolean());
3432     }
3433
3434     #[test]
3435     fn test_as_boolean(){
3436         let json_value = from_str("false").unwrap();
3437         let json_bool = json_value.as_boolean();
3438         let expected_bool = false;
3439         assert!(json_bool.is_some() && json_bool.unwrap() == expected_bool);
3440     }
3441
3442     #[test]
3443     fn test_is_null(){
3444         let json_value = from_str("null").unwrap();
3445         assert!(json_value.is_null());
3446     }
3447
3448     #[test]
3449     fn test_as_null(){
3450         let json_value = from_str("null").unwrap();
3451         let json_null = json_value.as_null();
3452         let expected_null = ();
3453         assert!(json_null.is_some() && json_null.unwrap() == expected_null);
3454     }
3455
3456     #[test]
3457     fn test_encode_hashmap_with_numeric_key() {
3458         use std::str::from_utf8;
3459         use std::collections::HashMap;
3460         let mut hm: HashMap<usize, bool> = HashMap::new();
3461         hm.insert(1, true);
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
3468         }
3469     }
3470
3471     #[test]
3472     fn test_prettyencode_hashmap_with_numeric_key() {
3473         use std::str::from_utf8;
3474         use std::collections::HashMap;
3475         let mut hm: HashMap<usize, bool> = HashMap::new();
3476         hm.insert(1, true);
3477         let mut mem_buf = Vec::new();
3478         write!(&mut mem_buf, "{}", super::as_pretty_json(&hm)).unwrap();
3479         let json_str = from_utf8(&mem_buf[..]).unwrap();
3480         match from_str(json_str) {
3481             Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
3482             _ => {} // it parsed and we are good to go
3483         }
3484     }
3485
3486     #[test]
3487     fn test_prettyencoder_indent_level_param() {
3488         use std::str::from_utf8;
3489         use std::collections::BTreeMap;
3490
3491         let mut tree = BTreeMap::new();
3492
3493         tree.insert("hello".to_string(), String("guten tag".to_string()));
3494         tree.insert("goodbye".to_string(), String("sayonara".to_string()));
3495
3496         let json = Array(
3497             // The following layout below should look a lot like
3498             // the pretty-printed JSON (indent * x)
3499             vec!
3500             ( // 0x
3501                 String("greetings".to_string()), // 1x
3502                 Object(tree), // 1x + 2x + 2x + 1x
3503             ) // 0x
3504             // End JSON array (7 lines)
3505         );
3506
3507         // Helper function for counting indents
3508         fn indents(source: &str) -> usize {
3509             let trimmed = source.trim_left_matches(' ');
3510             source.len() - trimmed.len()
3511         }
3512
3513         // Test up to 4 spaces of indents (more?)
3514         for i in 0..4 {
3515             let mut writer = Vec::new();
3516             write!(&mut writer, "{}",
3517                    super::as_pretty_json(&json).indent(i)).unwrap();
3518
3519             let printed = from_utf8(&writer[..]).unwrap();
3520
3521             // Check for indents at each line
3522             let lines: Vec<&str> = printed.lines().collect();
3523             assert_eq!(lines.len(), 7); // JSON should be 7 lines
3524
3525             assert_eq!(indents(lines[0]), 0 * i); // [
3526             assert_eq!(indents(lines[1]), 1 * i); //   "greetings",
3527             assert_eq!(indents(lines[2]), 1 * i); //   {
3528             assert_eq!(indents(lines[3]), 2 * i); //     "hello": "guten tag",
3529             assert_eq!(indents(lines[4]), 2 * i); //     "goodbye": "sayonara"
3530             assert_eq!(indents(lines[5]), 1 * i); //   },
3531             assert_eq!(indents(lines[6]), 0 * i); // ]
3532
3533             // Finally, test that the pretty-printed JSON is valid
3534             from_str(printed).ok().expect("Pretty-printed JSON is invalid!");
3535         }
3536     }
3537
3538     #[test]
3539     fn test_hashmap_with_enum_key() {
3540         use std::collections::HashMap;
3541         use json;
3542         #[derive(RustcEncodable, Eq, Hash, PartialEq, RustcDecodable, Debug)]
3543         enum Enum {
3544             Foo,
3545             #[allow(dead_code)]
3546             Bar,
3547         }
3548         let mut map = HashMap::new();
3549         map.insert(Enum::Foo, 0);
3550         let result = json::encode(&map).unwrap();
3551         assert_eq!(&result[..], r#"{"Foo":0}"#);
3552         let decoded: HashMap<Enum, _> = json::decode(&result).unwrap();
3553         assert_eq!(map, decoded);
3554     }
3555
3556     #[test]
3557     fn test_hashmap_with_numeric_key_can_handle_double_quote_delimited_key() {
3558         use std::collections::HashMap;
3559         use Decodable;
3560         let json_str = "{\"1\":true}";
3561         let json_obj = match from_str(json_str) {
3562             Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
3563             Ok(o) => o
3564         };
3565         let mut decoder = Decoder::new(json_obj);
3566         let _hm: HashMap<usize, bool> = Decodable::decode(&mut decoder).unwrap();
3567     }
3568
3569     #[test]
3570     fn test_hashmap_with_numeric_key_will_error_with_string_keys() {
3571         use std::collections::HashMap;
3572         use Decodable;
3573         let json_str = "{\"a\":true}";
3574         let json_obj = match from_str(json_str) {
3575             Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
3576             Ok(o) => o
3577         };
3578         let mut decoder = Decoder::new(json_obj);
3579         let result: Result<HashMap<usize, bool>, DecoderError> = Decodable::decode(&mut decoder);
3580         assert_eq!(result, Err(ExpectedError("Number".to_string(), "a".to_string())));
3581     }
3582
3583     fn assert_stream_equal(src: &str,
3584                            expected: Vec<(JsonEvent, Vec<StackElement>)>) {
3585         let mut parser = Parser::new(src.chars());
3586         let mut i = 0;
3587         loop {
3588             let evt = match parser.next() {
3589                 Some(e) => e,
3590                 None => { break; }
3591             };
3592             let (ref expected_evt, ref expected_stack) = expected[i];
3593             if !parser.stack().is_equal_to(expected_stack) {
3594                 panic!("Parser stack is not equal to {:?}", expected_stack);
3595             }
3596             assert_eq!(&evt, expected_evt);
3597             i+=1;
3598         }
3599     }
3600     #[test]
3601     #[cfg_attr(target_pointer_width = "32", ignore)] // FIXME(#14064)
3602     fn test_streaming_parser() {
3603         assert_stream_equal(
3604             r#"{ "foo":"bar", "array" : [0, 1, 2, 3, 4, 5], "idents":[null,true,false]}"#,
3605             vec![
3606                 (ObjectStart,             vec![]),
3607                   (StringValue("bar".to_string()),   vec![StackElement::Key("foo")]),
3608                   (ArrayStart,            vec![StackElement::Key("array")]),
3609                     (U64Value(0),         vec![StackElement::Key("array"), StackElement::Index(0)]),
3610                     (U64Value(1),         vec![StackElement::Key("array"), StackElement::Index(1)]),
3611                     (U64Value(2),         vec![StackElement::Key("array"), StackElement::Index(2)]),
3612                     (U64Value(3),         vec![StackElement::Key("array"), StackElement::Index(3)]),
3613                     (U64Value(4),         vec![StackElement::Key("array"), StackElement::Index(4)]),
3614                     (U64Value(5),         vec![StackElement::Key("array"), StackElement::Index(5)]),
3615                   (ArrayEnd,              vec![StackElement::Key("array")]),
3616                   (ArrayStart,            vec![StackElement::Key("idents")]),
3617                     (NullValue,           vec![StackElement::Key("idents"),
3618                                                StackElement::Index(0)]),
3619                     (BooleanValue(true),  vec![StackElement::Key("idents"),
3620                                                StackElement::Index(1)]),
3621                     (BooleanValue(false), vec![StackElement::Key("idents"),
3622                                                StackElement::Index(2)]),
3623                   (ArrayEnd,              vec![StackElement::Key("idents")]),
3624                 (ObjectEnd,               vec![]),
3625             ]
3626         );
3627     }
3628     fn last_event(src: &str) -> JsonEvent {
3629         let mut parser = Parser::new(src.chars());
3630         let mut evt = NullValue;
3631         loop {
3632             evt = match parser.next() {
3633                 Some(e) => e,
3634                 None => return evt,
3635             }
3636         }
3637     }
3638
3639     #[test]
3640     #[cfg_attr(target_pointer_width = "32", ignore)] // FIXME(#14064)
3641     fn test_read_object_streaming() {
3642         assert_eq!(last_event("{ "),      Error(SyntaxError(EOFWhileParsingObject, 1, 3)));
3643         assert_eq!(last_event("{1"),      Error(SyntaxError(KeyMustBeAString,      1, 2)));
3644         assert_eq!(last_event("{ \"a\""), Error(SyntaxError(EOFWhileParsingObject, 1, 6)));
3645         assert_eq!(last_event("{\"a\""),  Error(SyntaxError(EOFWhileParsingObject, 1, 5)));
3646         assert_eq!(last_event("{\"a\" "), Error(SyntaxError(EOFWhileParsingObject, 1, 6)));
3647
3648         assert_eq!(last_event("{\"a\" 1"),   Error(SyntaxError(ExpectedColon,         1, 6)));
3649         assert_eq!(last_event("{\"a\":"),    Error(SyntaxError(EOFWhileParsingValue,  1, 6)));
3650         assert_eq!(last_event("{\"a\":1"),   Error(SyntaxError(EOFWhileParsingObject, 1, 7)));
3651         assert_eq!(last_event("{\"a\":1 1"), Error(SyntaxError(InvalidSyntax,         1, 8)));
3652         assert_eq!(last_event("{\"a\":1,"),  Error(SyntaxError(EOFWhileParsingObject, 1, 8)));
3653         assert_eq!(last_event("{\"a\":1,}"), Error(SyntaxError(TrailingComma, 1, 8)));
3654
3655         assert_stream_equal(
3656             "{}",
3657             vec![(ObjectStart, vec![]), (ObjectEnd, vec![])]
3658         );
3659         assert_stream_equal(
3660             "{\"a\": 3}",
3661             vec![
3662                 (ObjectStart,        vec![]),
3663                   (U64Value(3),      vec![StackElement::Key("a")]),
3664                 (ObjectEnd,          vec![]),
3665             ]
3666         );
3667         assert_stream_equal(
3668             "{ \"a\": null, \"b\" : true }",
3669             vec![
3670                 (ObjectStart,           vec![]),
3671                   (NullValue,           vec![StackElement::Key("a")]),
3672                   (BooleanValue(true),  vec![StackElement::Key("b")]),
3673                 (ObjectEnd,             vec![]),
3674             ]
3675         );
3676         assert_stream_equal(
3677             "{\"a\" : 1.0 ,\"b\": [ true ]}",
3678             vec![
3679                 (ObjectStart,           vec![]),
3680                   (F64Value(1.0),       vec![StackElement::Key("a")]),
3681                   (ArrayStart,          vec![StackElement::Key("b")]),
3682                     (BooleanValue(true),vec![StackElement::Key("b"), StackElement::Index(0)]),
3683                   (ArrayEnd,            vec![StackElement::Key("b")]),
3684                 (ObjectEnd,             vec![]),
3685             ]
3686         );
3687         assert_stream_equal(
3688             r#"{
3689                 "a": 1.0,
3690                 "b": [
3691                     true,
3692                     "foo\nbar",
3693                     { "c": {"d": null} }
3694                 ]
3695             }"#,
3696             vec![
3697                 (ObjectStart,                   vec![]),
3698                   (F64Value(1.0),               vec![StackElement::Key("a")]),
3699                   (ArrayStart,                  vec![StackElement::Key("b")]),
3700                     (BooleanValue(true),        vec![StackElement::Key("b"),
3701                                                      StackElement::Index(0)]),
3702                     (StringValue("foo\nbar".to_string()),  vec![StackElement::Key("b"),
3703                                                                 StackElement::Index(1)]),
3704                     (ObjectStart,               vec![StackElement::Key("b"),
3705                                                      StackElement::Index(2)]),
3706                       (ObjectStart,             vec![StackElement::Key("b"),
3707                                                      StackElement::Index(2),
3708                                                      StackElement::Key("c")]),
3709                         (NullValue,             vec![StackElement::Key("b"),
3710                                                      StackElement::Index(2),
3711                                                      StackElement::Key("c"),
3712                                                      StackElement::Key("d")]),
3713                       (ObjectEnd,               vec![StackElement::Key("b"),
3714                                                      StackElement::Index(2),
3715                                                      StackElement::Key("c")]),
3716                     (ObjectEnd,                 vec![StackElement::Key("b"),
3717                                                      StackElement::Index(2)]),
3718                   (ArrayEnd,                    vec![StackElement::Key("b")]),
3719                 (ObjectEnd,                     vec![]),
3720             ]
3721         );
3722     }
3723     #[test]
3724     #[cfg_attr(target_pointer_width = "32", ignore)] // FIXME(#14064)
3725     fn test_read_array_streaming() {
3726         assert_stream_equal(
3727             "[]",
3728             vec![
3729                 (ArrayStart, vec![]),
3730                 (ArrayEnd,   vec![]),
3731             ]
3732         );
3733         assert_stream_equal(
3734             "[ ]",
3735             vec![
3736                 (ArrayStart, vec![]),
3737                 (ArrayEnd,   vec![]),
3738             ]
3739         );
3740         assert_stream_equal(
3741             "[true]",
3742             vec![
3743                 (ArrayStart,             vec![]),
3744                     (BooleanValue(true), vec![StackElement::Index(0)]),
3745                 (ArrayEnd,               vec![]),
3746             ]
3747         );
3748         assert_stream_equal(
3749             "[ false ]",
3750             vec![
3751                 (ArrayStart,              vec![]),
3752                     (BooleanValue(false), vec![StackElement::Index(0)]),
3753                 (ArrayEnd,                vec![]),
3754             ]
3755         );
3756         assert_stream_equal(
3757             "[null]",
3758             vec![
3759                 (ArrayStart,    vec![]),
3760                     (NullValue, vec![StackElement::Index(0)]),
3761                 (ArrayEnd,      vec![]),
3762             ]
3763         );
3764         assert_stream_equal(
3765             "[3, 1]",
3766             vec![
3767                 (ArrayStart,      vec![]),
3768                     (U64Value(3), vec![StackElement::Index(0)]),
3769                     (U64Value(1), vec![StackElement::Index(1)]),
3770                 (ArrayEnd,        vec![]),
3771             ]
3772         );
3773         assert_stream_equal(
3774             "\n[3, 2]\n",
3775             vec![
3776                 (ArrayStart,      vec![]),
3777                     (U64Value(3), vec![StackElement::Index(0)]),
3778                     (U64Value(2), vec![StackElement::Index(1)]),
3779                 (ArrayEnd,        vec![]),
3780             ]
3781         );
3782         assert_stream_equal(
3783             "[2, [4, 1]]",
3784             vec![
3785                 (ArrayStart,           vec![]),
3786                     (U64Value(2),      vec![StackElement::Index(0)]),
3787                     (ArrayStart,       vec![StackElement::Index(1)]),
3788                         (U64Value(4),  vec![StackElement::Index(1), StackElement::Index(0)]),
3789                         (U64Value(1),  vec![StackElement::Index(1), StackElement::Index(1)]),
3790                     (ArrayEnd,         vec![StackElement::Index(1)]),
3791                 (ArrayEnd,             vec![]),
3792             ]
3793         );
3794
3795         assert_eq!(last_event("["), Error(SyntaxError(EOFWhileParsingValue, 1,  2)));
3796
3797         assert_eq!(from_str("["),     Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
3798         assert_eq!(from_str("[1"),    Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
3799         assert_eq!(from_str("[1,"),   Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
3800         assert_eq!(from_str("[1,]"),  Err(SyntaxError(InvalidSyntax,        1, 4)));
3801         assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax,        1, 4)));
3802
3803     }
3804     #[test]
3805     fn test_trailing_characters_streaming() {
3806         assert_eq!(last_event("nulla"),  Error(SyntaxError(TrailingCharacters, 1, 5)));
3807         assert_eq!(last_event("truea"),  Error(SyntaxError(TrailingCharacters, 1, 5)));
3808         assert_eq!(last_event("falsea"), Error(SyntaxError(TrailingCharacters, 1, 6)));
3809         assert_eq!(last_event("1a"),     Error(SyntaxError(TrailingCharacters, 1, 2)));
3810         assert_eq!(last_event("[]a"),    Error(SyntaxError(TrailingCharacters, 1, 3)));
3811         assert_eq!(last_event("{}a"),    Error(SyntaxError(TrailingCharacters, 1, 3)));
3812     }
3813     #[test]
3814     fn test_read_identifiers_streaming() {
3815         assert_eq!(Parser::new("null".chars()).next(), Some(NullValue));
3816         assert_eq!(Parser::new("true".chars()).next(), Some(BooleanValue(true)));
3817         assert_eq!(Parser::new("false".chars()).next(), Some(BooleanValue(false)));
3818
3819         assert_eq!(last_event("n"),    Error(SyntaxError(InvalidSyntax, 1, 2)));
3820         assert_eq!(last_event("nul"),  Error(SyntaxError(InvalidSyntax, 1, 4)));
3821         assert_eq!(last_event("t"),    Error(SyntaxError(InvalidSyntax, 1, 2)));
3822         assert_eq!(last_event("truz"), Error(SyntaxError(InvalidSyntax, 1, 4)));
3823         assert_eq!(last_event("f"),    Error(SyntaxError(InvalidSyntax, 1, 2)));
3824         assert_eq!(last_event("faz"),  Error(SyntaxError(InvalidSyntax, 1, 3)));
3825     }
3826
3827     #[test]
3828     fn test_stack() {
3829         let mut stack = Stack::new();
3830
3831         assert!(stack.is_empty());
3832         assert!(stack.is_empty());
3833         assert!(!stack.last_is_index());
3834
3835         stack.push_index(0);
3836         stack.bump_index();
3837
3838         assert!(stack.len() == 1);
3839         assert!(stack.is_equal_to(&[StackElement::Index(1)]));
3840         assert!(stack.starts_with(&[StackElement::Index(1)]));
3841         assert!(stack.ends_with(&[StackElement::Index(1)]));
3842         assert!(stack.last_is_index());
3843         assert!(stack.get(0) == StackElement::Index(1));
3844
3845         stack.push_key("foo".to_string());
3846
3847         assert!(stack.len() == 2);
3848         assert!(stack.is_equal_to(&[StackElement::Index(1), StackElement::Key("foo")]));
3849         assert!(stack.starts_with(&[StackElement::Index(1), StackElement::Key("foo")]));
3850         assert!(stack.starts_with(&[StackElement::Index(1)]));
3851         assert!(stack.ends_with(&[StackElement::Index(1), StackElement::Key("foo")]));
3852         assert!(stack.ends_with(&[StackElement::Key("foo")]));
3853         assert!(!stack.last_is_index());
3854         assert!(stack.get(0) == StackElement::Index(1));
3855         assert!(stack.get(1) == StackElement::Key("foo"));
3856
3857         stack.push_key("bar".to_string());
3858
3859         assert!(stack.len() == 3);
3860         assert!(stack.is_equal_to(&[StackElement::Index(1),
3861                                     StackElement::Key("foo"),
3862                                     StackElement::Key("bar")]));
3863         assert!(stack.starts_with(&[StackElement::Index(1)]));
3864         assert!(stack.starts_with(&[StackElement::Index(1), StackElement::Key("foo")]));
3865         assert!(stack.starts_with(&[StackElement::Index(1),
3866                                     StackElement::Key("foo"),
3867                                     StackElement::Key("bar")]));
3868         assert!(stack.ends_with(&[StackElement::Key("bar")]));
3869         assert!(stack.ends_with(&[StackElement::Key("foo"), StackElement::Key("bar")]));
3870         assert!(stack.ends_with(&[StackElement::Index(1),
3871                                   StackElement::Key("foo"),
3872                                   StackElement::Key("bar")]));
3873         assert!(!stack.last_is_index());
3874         assert!(stack.get(0) == StackElement::Index(1));
3875         assert!(stack.get(1) == StackElement::Key("foo"));
3876         assert!(stack.get(2) == StackElement::Key("bar"));
3877
3878         stack.pop();
3879
3880         assert!(stack.len() == 2);
3881         assert!(stack.is_equal_to(&[StackElement::Index(1), StackElement::Key("foo")]));
3882         assert!(stack.starts_with(&[StackElement::Index(1), StackElement::Key("foo")]));
3883         assert!(stack.starts_with(&[StackElement::Index(1)]));
3884         assert!(stack.ends_with(&[StackElement::Index(1), StackElement::Key("foo")]));
3885         assert!(stack.ends_with(&[StackElement::Key("foo")]));
3886         assert!(!stack.last_is_index());
3887         assert!(stack.get(0) == StackElement::Index(1));
3888         assert!(stack.get(1) == StackElement::Key("foo"));
3889     }
3890
3891     #[test]
3892     fn test_to_json() {
3893         use std::collections::{HashMap,BTreeMap};
3894         use super::ToJson;
3895
3896         let array2 = Array(vec!(U64(1), U64(2)));
3897         let array3 = Array(vec!(U64(1), U64(2), U64(3)));
3898         let object = {
3899             let mut tree_map = BTreeMap::new();
3900             tree_map.insert("a".to_string(), U64(1));
3901             tree_map.insert("b".to_string(), U64(2));
3902             Object(tree_map)
3903         };
3904
3905         assert_eq!(array2.to_json(), array2);
3906         assert_eq!(object.to_json(), object);
3907         assert_eq!(3_isize.to_json(), I64(3));
3908         assert_eq!(4_i8.to_json(), I64(4));
3909         assert_eq!(5_i16.to_json(), I64(5));
3910         assert_eq!(6_i32.to_json(), I64(6));
3911         assert_eq!(7_i64.to_json(), I64(7));
3912         assert_eq!(8_usize.to_json(), U64(8));
3913         assert_eq!(9_u8.to_json(), U64(9));
3914         assert_eq!(10_u16.to_json(), U64(10));
3915         assert_eq!(11_u32.to_json(), U64(11));
3916         assert_eq!(12_u64.to_json(), U64(12));
3917         assert_eq!(13.0_f32.to_json(), F64(13.0_f64));
3918         assert_eq!(14.0_f64.to_json(), F64(14.0_f64));
3919         assert_eq!(().to_json(), Null);
3920         assert_eq!(f32::INFINITY.to_json(), Null);
3921         assert_eq!(f64::NAN.to_json(), Null);
3922         assert_eq!(true.to_json(), Boolean(true));
3923         assert_eq!(false.to_json(), Boolean(false));
3924         assert_eq!("abc".to_json(), String("abc".to_string()));
3925         assert_eq!("abc".to_string().to_json(), String("abc".to_string()));
3926         assert_eq!((1_usize, 2_usize).to_json(), array2);
3927         assert_eq!((1_usize, 2_usize, 3_usize).to_json(), array3);
3928         assert_eq!([1_usize, 2_usize].to_json(), array2);
3929         assert_eq!((&[1_usize, 2_usize, 3_usize]).to_json(), array3);
3930         assert_eq!((vec![1_usize, 2_usize]).to_json(), array2);
3931         assert_eq!(vec!(1_usize, 2_usize, 3_usize).to_json(), array3);
3932         let mut tree_map = BTreeMap::new();
3933         tree_map.insert("a".to_string(), 1 as usize);
3934         tree_map.insert("b".to_string(), 2);
3935         assert_eq!(tree_map.to_json(), object);
3936         let mut hash_map = HashMap::new();
3937         hash_map.insert("a".to_string(), 1 as usize);
3938         hash_map.insert("b".to_string(), 2);
3939         assert_eq!(hash_map.to_json(), object);
3940         assert_eq!(Some(15).to_json(), I64(15));
3941         assert_eq!(Some(15 as usize).to_json(), U64(15));
3942         assert_eq!(None::<isize>.to_json(), Null);
3943     }
3944
3945     #[test]
3946     fn test_encode_hashmap_with_arbitrary_key() {
3947         use std::collections::HashMap;
3948         #[derive(PartialEq, Eq, Hash, RustcEncodable)]
3949         struct ArbitraryType(usize);
3950         let mut hm: HashMap<ArbitraryType, bool> = HashMap::new();
3951         hm.insert(ArbitraryType(1), true);
3952         let mut mem_buf = string::String::new();
3953         let mut encoder = Encoder::new(&mut mem_buf);
3954         let result = hm.encode(&mut encoder);
3955         match result.err().unwrap() {
3956             EncoderError::BadHashmapKey => (),
3957             _ => panic!("expected bad hash map key")
3958         }
3959     }
3960
3961     #[bench]
3962     fn bench_streaming_small(b: &mut Bencher) {
3963         b.iter( || {
3964             let mut parser = Parser::new(
3965                 r#"{
3966                     "a": 1.0,
3967                     "b": [
3968                         true,
3969                         "foo\nbar",
3970                         { "c": {"d": null} }
3971                     ]
3972                 }"#.chars()
3973             );
3974             loop {
3975                 match parser.next() {
3976                     None => return,
3977                     _ => {}
3978                 }
3979             }
3980         });
3981     }
3982     #[bench]
3983     fn bench_small(b: &mut Bencher) {
3984         b.iter( || {
3985             let _ = from_str(r#"{
3986                 "a": 1.0,
3987                 "b": [
3988                     true,
3989                     "foo\nbar",
3990                     { "c": {"d": null} }
3991                 ]
3992             }"#);
3993         });
3994     }
3995
3996     fn big_json() -> string::String {
3997         let mut src = "[\n".to_string();
3998         for _ in 0..500 {
3999             src.push_str(r#"{ "a": true, "b": null, "c":3.1415, "d": "Hello world", "e": \
4000                             [1,2,3]},"#);
4001         }
4002         src.push_str("{}]");
4003         return src;
4004     }
4005
4006     #[bench]
4007     fn bench_streaming_large(b: &mut Bencher) {
4008         let src = big_json();
4009         b.iter( || {
4010             let mut parser = Parser::new(src.chars());
4011             loop {
4012                 match parser.next() {
4013                     None => return,
4014                     _ => {}
4015                 }
4016             }
4017         });
4018     }
4019     #[bench]
4020     fn bench_large(b: &mut Bencher) {
4021         let src = big_json();
4022         b.iter( || { let _ = from_str(&src); });
4023     }
4024 }