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