OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

auto merge of #10727 : erickt/rust/json, r=huonw 

This PR does some small modernizations to the json library. First is to remove the `@` boxes, second is to rename the constructors to `new`.
This commit is contained in:
bors 2013-11-30 06:06:42 -08:00
parent eeaf2e1ddc a7b311ac61
commit 9bf62f71bc
7 changed files with 200 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

346
src/libextra/json.rs
View File

@ -54,7 +54,7 @@ pub struct Error {
/// The column number at which the error occurred /// The column number at which the error occurred
priv col: uint, priv col: uint,
/// A message describing the type of the error /// A message describing the type of the error
priv msg: @~str, priv msg: ~str,
} }
fn escape_str(s: &str) -> ~str { fn escape_str(s: &str) -> ~str {
@ -84,17 +84,19 @@ fn spaces(n: uint) -> ~str {
} }
/// A structure for implementing serialization to JSON. /// A structure for implementing serialization to JSON.
pub struct Encoder { pub struct Encoder<'self> {
priv wr: @mut io::Writer, priv wr: &'self mut io::Writer,
} }
/// Creates a new JSON encoder whose output will be written to the writer impl<'self> Encoder<'self> {
/// specified. /// Creates a new JSON encoder whose output will be written to the writer
pub fn Encoder(wr: @mut io::Writer) -> Encoder { /// specified.
Encoder { wr: wr } pub fn init<'a>(wr: &'a mut io::Writer) -> Encoder<'a> {
Encoder { wr: wr }
}
} }
impl serialize::Encoder for Encoder { impl<'self> serialize::Encoder for Encoder<'self> {
fn emit_nil(&mut self) { write!(self.wr, "null") } fn emit_nil(&mut self) { write!(self.wr, "null") }
fn emit_uint(&mut self, v: uint) { self.emit_f64(v as f64); } fn emit_uint(&mut self, v: uint) { self.emit_f64(v as f64); }
@ -127,13 +129,13 @@ impl serialize::Encoder for Encoder {
write!(self.wr, "{}", escape_str(v)) write!(self.wr, "{}", escape_str(v))
} }
fn emit_enum(&mut self, _name: &str, f: |&mut Encoder|) { f(self) } fn emit_enum(&mut self, _name: &str, f: |&mut Encoder<'self>|) { f(self) }
fn emit_enum_variant(&mut self, fn emit_enum_variant(&mut self,
name: &str, name: &str,
_id: uint, _id: uint,
cnt: uint, cnt: uint,
f: |&mut Encoder|) { f: |&mut Encoder<'self>|) {
// enums are encoded as strings or objects // enums are encoded as strings or objects
// Bunny => "Bunny" // Bunny => "Bunny"
// Kangaroo(34,"William") => {"variant": "Kangaroo", "fields": [34,"William"]} // Kangaroo(34,"William") => {"variant": "Kangaroo", "fields": [34,"William"]}
@ -148,7 +150,7 @@ impl serialize::Encoder for Encoder {
} }
} }
fn emit_enum_variant_arg(&mut self, idx: uint, f: |&mut Encoder|) { fn emit_enum_variant_arg(&mut self, idx: uint, f: |&mut Encoder<'self>|) {
if idx != 0 { if idx != 0 {
write!(self.wr, ","); write!(self.wr, ",");
} }
@ -159,18 +161,18 @@ impl serialize::Encoder for Encoder {
name: &str, name: &str,
id: uint, id: uint,
cnt: uint, cnt: uint,
f: |&mut Encoder|) { f: |&mut Encoder<'self>|) {
self.emit_enum_variant(name, id, cnt, f) self.emit_enum_variant(name, id, cnt, f)
} }
fn emit_enum_struct_variant_field(&mut self, fn emit_enum_struct_variant_field(&mut self,
_: &str, _: &str,
idx: uint, idx: uint,
f: |&mut Encoder|) { f: |&mut Encoder<'self>|) {
self.emit_enum_variant_arg(idx, f) self.emit_enum_variant_arg(idx, f)
} }
fn emit_struct(&mut self, _: &str, _: uint, f: |&mut Encoder|) { fn emit_struct(&mut self, _: &str, _: uint, f: |&mut Encoder<'self>|) {
write!(self.wr, r"\{"); write!(self.wr, r"\{");
f(self); f(self);
write!(self.wr, r"\}"); write!(self.wr, r"\}");
@ -179,58 +181,58 @@ impl serialize::Encoder for Encoder {
fn emit_struct_field(&mut self, fn emit_struct_field(&mut self,
name: &str, name: &str,
idx: uint, idx: uint,
f: |&mut Encoder|) { f: |&mut Encoder<'self>|) {
if idx != 0 { write!(self.wr, ",") } if idx != 0 { write!(self.wr, ",") }
write!(self.wr, "{}:", escape_str(name)); write!(self.wr, "{}:", escape_str(name));
f(self); f(self);
} }
fn emit_tuple(&mut self, len: uint, f: |&mut Encoder|) { fn emit_tuple(&mut self, len: uint, f: |&mut Encoder<'self>|) {
self.emit_seq(len, f) self.emit_seq(len, f)
} }
fn emit_tuple_arg(&mut self, idx: uint, f: |&mut Encoder|) { fn emit_tuple_arg(&mut self, idx: uint, f: |&mut Encoder<'self>|) {
self.emit_seq_elt(idx, f) self.emit_seq_elt(idx, f)
} }
fn emit_tuple_struct(&mut self, fn emit_tuple_struct(&mut self,
_name: &str, _name: &str,
len: uint, len: uint,
f: |&mut Encoder|) { f: |&mut Encoder<'self>|) {
self.emit_seq(len, f) self.emit_seq(len, f)
} }
fn emit_tuple_struct_arg(&mut self, idx: uint, f: |&mut Encoder|) { fn emit_tuple_struct_arg(&mut self, idx: uint, f: |&mut Encoder<'self>|) {
self.emit_seq_elt(idx, f) self.emit_seq_elt(idx, f)
} }
fn emit_option(&mut self, f: |&mut Encoder|) { f(self); } fn emit_option(&mut self, f: |&mut Encoder<'self>|) { f(self); }
fn emit_option_none(&mut self) { self.emit_nil(); } fn emit_option_none(&mut self) { self.emit_nil(); }
fn emit_option_some(&mut self, f: |&mut Encoder|) { f(self); } fn emit_option_some(&mut self, f: |&mut Encoder<'self>|) { f(self); }
fn emit_seq(&mut self, _len: uint, f: |&mut Encoder|) { fn emit_seq(&mut self, _len: uint, f: |&mut Encoder<'self>|) {
write!(self.wr, "["); write!(self.wr, "[");
f(self); f(self);
write!(self.wr, "]"); write!(self.wr, "]");
} }
fn emit_seq_elt(&mut self, idx: uint, f: |&mut Encoder|) { fn emit_seq_elt(&mut self, idx: uint, f: |&mut Encoder<'self>|) {
if idx != 0 { if idx != 0 {
write!(self.wr, ","); write!(self.wr, ",");
} }
f(self) f(self)
} }
fn emit_map(&mut self, _len: uint, f: |&mut Encoder|) { fn emit_map(&mut self, _len: uint, f: |&mut Encoder<'self>|) {
write!(self.wr, r"\{"); write!(self.wr, r"\{");
f(self); f(self);
write!(self.wr, r"\}"); write!(self.wr, r"\}");
} }
fn emit_map_elt_key(&mut self, idx: uint, f: |&mut Encoder|) { fn emit_map_elt_key(&mut self, idx: uint, f: |&mut Encoder<'self>|) {
if idx != 0 { write!(self.wr, ",") } if idx != 0 { write!(self.wr, ",") }
f(self) f(self)
} }
fn emit_map_elt_val(&mut self, _idx: uint, f: |&mut Encoder|) { fn emit_map_elt_val(&mut self, _idx: uint, f: |&mut Encoder<'self>|) {
write!(self.wr, ":"); write!(self.wr, ":");
f(self) f(self)
} }
@ -238,20 +240,22 @@ impl serialize::Encoder for Encoder {
/// Another encoder for JSON, but prints out human-readable JSON instead of /// Another encoder for JSON, but prints out human-readable JSON instead of
/// compact data /// compact data
pub struct PrettyEncoder { pub struct PrettyEncoder<'self> {
priv wr: @mut io::Writer, priv wr: &'self mut io::Writer,
priv indent: uint, priv indent: uint,
} }
/// Creates a new encoder whose output will be written to the specified writer impl<'self> PrettyEncoder<'self> {
pub fn PrettyEncoder(wr: @mut io::Writer) -> PrettyEncoder { /// Creates a new encoder whose output will be written to the specified writer
PrettyEncoder { pub fn init<'a>(wr: &'a mut io::Writer) -> PrettyEncoder<'a> {
wr: wr, PrettyEncoder {
indent: 0, wr: wr,
indent: 0,
}
} }
} }
impl serialize::Encoder for PrettyEncoder { impl<'self> serialize::Encoder for PrettyEncoder<'self> {
fn emit_nil(&mut self) { write!(self.wr, "null") } fn emit_nil(&mut self) { write!(self.wr, "null") }
fn emit_uint(&mut self, v: uint) { self.emit_f64(v as f64); } fn emit_uint(&mut self, v: uint) { self.emit_f64(v as f64); }
@ -282,7 +286,7 @@ impl serialize::Encoder for PrettyEncoder {
fn emit_char(&mut self, v: char) { self.emit_str(str::from_char(v)) } fn emit_char(&mut self, v: char) { self.emit_str(str::from_char(v)) }
fn emit_str(&mut self, v: &str) { write!(self.wr, "{}", escape_str(v)); } fn emit_str(&mut self, v: &str) { write!(self.wr, "{}", escape_str(v)); }
fn emit_enum(&mut self, _name: &str, f: |&mut PrettyEncoder|) { fn emit_enum(&mut self, _name: &str, f: |&mut PrettyEncoder<'self>|) {
f(self) f(self)
} }
@ -290,7 +294,7 @@ impl serialize::Encoder for PrettyEncoder {
name: &str, name: &str,
_: uint, _: uint,
cnt: uint, cnt: uint,
f: |&mut PrettyEncoder|) { f: |&mut PrettyEncoder<'self>|) {
if cnt == 0 { if cnt == 0 {
write!(self.wr, "{}", escape_str(name)); write!(self.wr, "{}", escape_str(name));
} else { } else {
@ -304,7 +308,7 @@ impl serialize::Encoder for PrettyEncoder {
fn emit_enum_variant_arg(&mut self, fn emit_enum_variant_arg(&mut self,
idx: uint, idx: uint,
f: |&mut PrettyEncoder|) { f: |&mut PrettyEncoder<'self>|) {
if idx != 0 { if idx != 0 {
write!(self.wr, ",\n"); write!(self.wr, ",\n");
} }
@ -316,14 +320,14 @@ impl serialize::Encoder for PrettyEncoder {
name: &str, name: &str,
id: uint, id: uint,
cnt: uint, cnt: uint,
f: |&mut PrettyEncoder|) { f: |&mut PrettyEncoder<'self>|) {
self.emit_enum_variant(name, id, cnt, f) self.emit_enum_variant(name, id, cnt, f)
} }
fn emit_enum_struct_variant_field(&mut self, fn emit_enum_struct_variant_field(&mut self,
_: &str, _: &str,
idx: uint, idx: uint,
f: |&mut PrettyEncoder|) { f: |&mut PrettyEncoder<'self>|) {
self.emit_enum_variant_arg(idx, f) self.emit_enum_variant_arg(idx, f)
} }
@ -331,7 +335,7 @@ impl serialize::Encoder for PrettyEncoder {
fn emit_struct(&mut self, fn emit_struct(&mut self,
_: &str, _: &str,
len: uint, len: uint,
f: |&mut PrettyEncoder|) { f: |&mut PrettyEncoder<'self>|) {
if len == 0 { if len == 0 {
write!(self.wr, "\\{\\}"); write!(self.wr, "\\{\\}");
} else { } else {
@ -346,7 +350,7 @@ impl serialize::Encoder for PrettyEncoder {
fn emit_struct_field(&mut self, fn emit_struct_field(&mut self,
name: &str, name: &str,
idx: uint, idx: uint,
f: |&mut PrettyEncoder|) { f: |&mut PrettyEncoder<'self>|) {
if idx == 0 { if idx == 0 {
write!(self.wr, "\n"); write!(self.wr, "\n");
} else { } else {
@ -356,30 +360,30 @@ impl serialize::Encoder for PrettyEncoder {
f(self); f(self);
} }
fn emit_tuple(&mut self, len: uint, f: |&mut PrettyEncoder|) { fn emit_tuple(&mut self, len: uint, f: |&mut PrettyEncoder<'self>|) {
self.emit_seq(len, f) self.emit_seq(len, f)
} }
fn emit_tuple_arg(&mut self, idx: uint, f: |&mut PrettyEncoder|) { fn emit_tuple_arg(&mut self, idx: uint, f: |&mut PrettyEncoder<'self>|) {
self.emit_seq_elt(idx, f) self.emit_seq_elt(idx, f)
} }
fn emit_tuple_struct(&mut self, fn emit_tuple_struct(&mut self,
_: &str, _: &str,
len: uint, len: uint,
f: |&mut PrettyEncoder|) { f: |&mut PrettyEncoder<'self>|) {
self.emit_seq(len, f) self.emit_seq(len, f)
} }
fn emit_tuple_struct_arg(&mut self, fn emit_tuple_struct_arg(&mut self,
idx: uint, idx: uint,
f: |&mut PrettyEncoder|) { f: |&mut PrettyEncoder<'self>|) {
self.emit_seq_elt(idx, f) self.emit_seq_elt(idx, f)
} }
fn emit_option(&mut self, f: |&mut PrettyEncoder|) { f(self); } fn emit_option(&mut self, f: |&mut PrettyEncoder<'self>|) { f(self); }
fn emit_option_none(&mut self) { self.emit_nil(); } fn emit_option_none(&mut self) { self.emit_nil(); }
fn emit_option_some(&mut self, f: |&mut PrettyEncoder|) { f(self); } fn emit_option_some(&mut self, f: |&mut PrettyEncoder<'self>|) { f(self); }
fn emit_seq(&mut self, len: uint, f: |&mut PrettyEncoder|) { fn emit_seq(&mut self, len: uint, f: |&mut PrettyEncoder<'self>|) {
if len == 0 { if len == 0 {
write!(self.wr, "[]"); write!(self.wr, "[]");
} else { } else {
@ -391,7 +395,7 @@ impl serialize::Encoder for PrettyEncoder {
} }
} }
fn emit_seq_elt(&mut self, idx: uint, f: |&mut PrettyEncoder|) { fn emit_seq_elt(&mut self, idx: uint, f: |&mut PrettyEncoder<'self>|) {
if idx == 0 { if idx == 0 {
write!(self.wr, "\n"); write!(self.wr, "\n");
} else { } else {
@ -401,7 +405,7 @@ impl serialize::Encoder for PrettyEncoder {
f(self) f(self)
} }
fn emit_map(&mut self, len: uint, f: |&mut PrettyEncoder|) { fn emit_map(&mut self, len: uint, f: |&mut PrettyEncoder<'self>|) {
if len == 0 { if len == 0 {
write!(self.wr, "\\{\\}"); write!(self.wr, "\\{\\}");
} else { } else {
@ -413,7 +417,7 @@ impl serialize::Encoder for PrettyEncoder {
} }
} }
fn emit_map_elt_key(&mut self, idx: uint, f: |&mut PrettyEncoder|) { fn emit_map_elt_key(&mut self, idx: uint, f: |&mut PrettyEncoder<'self>|) {
if idx == 0 { if idx == 0 {
write!(self.wr, "\n"); write!(self.wr, "\n");
} else { } else {
@ -423,7 +427,7 @@ impl serialize::Encoder for PrettyEncoder {
f(self); f(self);
} }
fn emit_map_elt_val(&mut self, _idx: uint, f: |&mut PrettyEncoder|) { fn emit_map_elt_val(&mut self, _idx: uint, f: |&mut PrettyEncoder<'self>|) {
write!(self.wr, ": "); write!(self.wr, ": ");
f(self); f(self);
} }
@ -444,43 +448,45 @@ impl<E: serialize::Encoder> serialize::Encodable<E> for Json {
impl Json{ impl Json{
/// Encodes a json value into a io::writer. Uses a single line. /// Encodes a json value into a io::writer. Uses a single line.
pub fn to_writer(&self, wr: @mut io::Writer) { pub fn to_writer(&self, wr: &mut io::Writer) {
let mut encoder = Encoder(wr); let mut encoder = Encoder::init(wr);
self.encode(&mut encoder) self.encode(&mut encoder)
} }
/// Encodes a json value into a io::writer. /// Encodes a json value into a io::writer.
/// Pretty-prints in a more readable format. /// Pretty-prints in a more readable format.
pub fn to_pretty_writer(&self, wr: @mut io::Writer) { pub fn to_pretty_writer(&self, wr: &mut io::Writer) {
let mut encoder = PrettyEncoder(wr); let mut encoder = PrettyEncoder::init(wr);
self.encode(&mut encoder) self.encode(&mut encoder)
} }
/// Encodes a json value into a string /// Encodes a json value into a string
pub fn to_pretty_str(&self) -> ~str { pub fn to_pretty_str(&self) -> ~str {
let s = @mut MemWriter::new(); let mut s = MemWriter::new();
self.to_pretty_writer(s as @mut io::Writer); self.to_pretty_writer(&mut s as &mut io::Writer);
str::from_utf8(s.inner_ref().as_slice()) str::from_utf8_owned(s.inner())
} }
} }
pub struct Parser<T> { pub struct Parser<T> {
priv rdr: ~T, priv rdr: T,
priv ch: char, priv ch: char,
priv line: uint, priv line: uint,
priv col: uint, priv col: uint,
} }
/// Decode a json value from an Iterator<char> impl<T: Iterator<char>> Parser<T> {
pub fn Parser<T : Iterator<char>>(rdr: ~T) -> Parser<T> { /// Decode a json value from an Iterator<char>
let mut p = Parser { pub fn init(rdr: T) -> Parser<T> {
rdr: rdr, let mut p = Parser {
ch: '\x00', rdr: rdr,
line: 1, ch: '\x00',
col: 0, line: 1,
}; col: 0,
p.bump(); };
p p.bump();
p
}
} }
impl<T: Iterator<char>> Parser<T> { impl<T: Iterator<char>> Parser<T> {
@ -525,7 +531,7 @@ impl<T : Iterator<char>> Parser<T> {
} }
fn error<T>(&self, msg: ~str) -> Result<T, Error> { fn error<T>(&self, msg: ~str) -> Result<T, Error> {
Err(Error { line: self.line, col: self.col, msg: @msg }) Err(Error { line: self.line, col: self.col, msg: msg })
} }
fn parse_value(&mut self) -> Result<Json, Error> { fn parse_value(&mut self) -> Result<Json, Error> {
@ -841,14 +847,14 @@ impl<T : Iterator<char>> Parser<T> {
/// Decodes a json value from an `&mut io::Reader` /// Decodes a json value from an `&mut io::Reader`
pub fn from_reader(rdr: &mut io::Reader) -> Result<Json, Error> { pub fn from_reader(rdr: &mut io::Reader) -> Result<Json, Error> {
let s = str::from_utf8(rdr.read_to_end()); let s = str::from_utf8_owned(rdr.read_to_end());
let mut parser = Parser(~s.chars()); let mut parser = Parser::init(s.chars());
parser.parse() parser.parse()
} }
/// Decodes a json value from a string /// Decodes a json value from a string
pub fn from_str(s: &str) -> Result<Json, Error> { pub fn from_str(s: &str) -> Result<Json, Error> {
let mut parser = Parser(~s.chars()); let mut parser = Parser::init(s.chars());
parser.parse() parser.parse()
} }
@ -857,10 +863,12 @@ pub struct Decoder {
priv stack: ~[Json], priv stack: ~[Json],
} }
/// Creates a new decoder instance for decoding the specified JSON value. impl Decoder {
pub fn Decoder(json: Json) -> Decoder { /// Creates a new decoder instance for decoding the specified JSON value.
Decoder { pub fn init(json: Json) -> Decoder {
stack: ~[json] Decoder {
stack: ~[json]
}
} }
} }
@ -1195,10 +1203,6 @@ impl ToJson for Json {
fn to_json(&self) -> Json { (*self).clone() } fn to_json(&self) -> Json { (*self).clone() }
} }
impl ToJson for @Json {
fn to_json(&self) -> Json { (**self).to_json() }
}
impl ToJson for int { impl ToJson for int {
fn to_json(&self) -> Json { Number(*self as f64) } fn to_json(&self) -> Json { Number(*self as f64) }
} }
@ -1259,10 +1263,6 @@ impl ToJson for ~str {
fn to_json(&self) -> Json { String((*self).clone()) } fn to_json(&self) -> Json { String((*self).clone()) }
} }
impl ToJson for @~str {
fn to_json(&self) -> Json { String((**self).clone()) }
}
impl<A:ToJson,B:ToJson> ToJson for (A, B) { impl<A:ToJson,B:ToJson> ToJson for (A, B) {
fn to_json(&self) -> Json { fn to_json(&self) -> Json {
match *self { match *self {
@ -1319,15 +1319,15 @@ impl<A:ToJson> ToJson for Option<A> {
impl to_str::ToStr for Json { impl to_str::ToStr for Json {
/// Encodes a json value into a string /// Encodes a json value into a string
fn to_str(&self) -> ~str { fn to_str(&self) -> ~str {
let s = @mut MemWriter::new(); let mut s = MemWriter::new();
self.to_writer(s as @mut io::Writer); self.to_writer(&mut s as &mut io::Writer);
str::from_utf8(s.inner_ref().as_slice()) str::from_utf8_owned(s.inner())
} }
} }
impl to_str::ToStr for Error { impl to_str::ToStr for Error {
fn to_str(&self) -> ~str { fn to_str(&self) -> ~str {
format!("{}:{}: {}", self.line, self.col, *self.msg) format!("{}:{}: {}", self.line, self.col, self.msg)
} }
} }
@ -1507,14 +1507,14 @@ mod tests {
assert_eq!(a.clone(), from_str(a.to_pretty_str()).unwrap()); assert_eq!(a.clone(), from_str(a.to_pretty_str()).unwrap());
} }
fn with_str_writer(f: |@mut io::Writer|) -> ~str { fn with_str_writer(f: |&mut io::Writer|) -> ~str {
use std::io::mem::MemWriter; use std::io::mem::MemWriter;
use std::io::Decorator; use std::io::Decorator;
use std::str; use std::str;
let m = @mut MemWriter::new(); let mut m = MemWriter::new();
f(m as @mut io::Writer); f(&mut m as &mut io::Writer);
str::from_utf8(*m.inner_ref()) str::from_utf8_owned(m.inner())
} }
#[test] #[test]
@ -1522,14 +1522,14 @@ mod tests {
let animal = Dog; let animal = Dog;
assert_eq!( assert_eq!(
with_str_writer(|wr| { with_str_writer(|wr| {
let mut encoder = Encoder(wr); let mut encoder = Encoder::init(wr);
animal.encode(&mut encoder); animal.encode(&mut encoder);
}), }),
~"\"Dog\"" ~"\"Dog\""
); );
assert_eq!( assert_eq!(
with_str_writer(|wr| { with_str_writer(|wr| {
let mut encoder = PrettyEncoder(wr); let mut encoder = PrettyEncoder::init(wr);
animal.encode(&mut encoder); animal.encode(&mut encoder);
}), }),
~"\"Dog\"" ~"\"Dog\""
@ -1538,14 +1538,14 @@ mod tests {
let animal = Frog(~"Henry", 349); let animal = Frog(~"Henry", 349);
assert_eq!( assert_eq!(
with_str_writer(|wr| { with_str_writer(|wr| {
let mut encoder = Encoder(wr); let mut encoder = Encoder::init(wr);
animal.encode(&mut encoder); animal.encode(&mut encoder);
}), }),
~"{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}" ~"{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"
); );
assert_eq!( assert_eq!(
with_str_writer(|wr| { with_str_writer(|wr| {
let mut encoder = PrettyEncoder(wr); let mut encoder = PrettyEncoder::init(wr);
animal.encode(&mut encoder); animal.encode(&mut encoder);
}), }),
~"\ ~"\
@ -1561,14 +1561,14 @@ mod tests {
fn test_write_some() { fn test_write_some() {
let value = Some(~"jodhpurs"); let value = Some(~"jodhpurs");
let s = with_str_writer(|wr| { let s = with_str_writer(|wr| {
let mut encoder = Encoder(wr); let mut encoder = Encoder::init(wr);
value.encode(&mut encoder); value.encode(&mut encoder);
}); });
assert_eq!(s, ~"\"jodhpurs\""); assert_eq!(s, ~"\"jodhpurs\"");
let value = Some(~"jodhpurs"); let value = Some(~"jodhpurs");
let s = with_str_writer(|wr| { let s = with_str_writer(|wr| {
let mut encoder = PrettyEncoder(wr); let mut encoder = PrettyEncoder::init(wr);
value.encode(&mut encoder); value.encode(&mut encoder);
}); });
assert_eq!(s, ~"\"jodhpurs\""); assert_eq!(s, ~"\"jodhpurs\"");
@ -1578,13 +1578,13 @@ mod tests {
fn test_write_none() { fn test_write_none() {
let value: Option<~str> = None; let value: Option<~str> = None;
let s = with_str_writer(|wr| { let s = with_str_writer(|wr| {
let mut encoder = Encoder(wr); let mut encoder = Encoder::init(wr);
value.encode(&mut encoder); value.encode(&mut encoder);
}); });
assert_eq!(s, ~"null"); assert_eq!(s, ~"null");
let s = with_str_writer(|wr| { let s = with_str_writer(|wr| {
let mut encoder = Encoder(wr); let mut encoder = Encoder::init(wr);
value.encode(&mut encoder); value.encode(&mut encoder);
}); });
assert_eq!(s, ~"null"); assert_eq!(s, ~"null");
@ -1593,35 +1593,35 @@ mod tests {
#[test] #[test]
fn test_trailing_characters() { fn test_trailing_characters() {
assert_eq!(from_str("nulla"), assert_eq!(from_str("nulla"),
Err(Error {line: 1u, col: 5u, msg: @~"trailing characters"})); Err(Error {line: 1u, col: 5u, msg: ~"trailing characters"}));
assert_eq!(from_str("truea"), assert_eq!(from_str("truea"),
Err(Error {line: 1u, col: 5u, msg: @~"trailing characters"})); Err(Error {line: 1u, col: 5u, msg: ~"trailing characters"}));
assert_eq!(from_str("falsea"), assert_eq!(from_str("falsea"),
Err(Error {line: 1u, col: 6u, msg: @~"trailing characters"})); Err(Error {line: 1u, col: 6u, msg: ~"trailing characters"}));
assert_eq!(from_str("1a"), assert_eq!(from_str("1a"),
Err(Error {line: 1u, col: 2u, msg: @~"trailing characters"})); Err(Error {line: 1u, col: 2u, msg: ~"trailing characters"}));
assert_eq!(from_str("[]a"), assert_eq!(from_str("[]a"),
Err(Error {line: 1u, col: 3u, msg: @~"trailing characters"})); Err(Error {line: 1u, col: 3u, msg: ~"trailing characters"}));
assert_eq!(from_str("{}a"), assert_eq!(from_str("{}a"),
Err(Error {line: 1u, col: 3u, msg: @~"trailing characters"})); Err(Error {line: 1u, col: 3u, msg: ~"trailing characters"}));
} }
#[test] #[test]
fn test_read_identifiers() { fn test_read_identifiers() {
assert_eq!(from_str("n"), assert_eq!(from_str("n"),
Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 2u, msg: ~"invalid syntax"}));
assert_eq!(from_str("nul"), assert_eq!(from_str("nul"),
Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 4u, msg: ~"invalid syntax"}));
assert_eq!(from_str("t"), assert_eq!(from_str("t"),
Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 2u, msg: ~"invalid syntax"}));
assert_eq!(from_str("truz"), assert_eq!(from_str("truz"),
Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 4u, msg: ~"invalid syntax"}));
assert_eq!(from_str("f"), assert_eq!(from_str("f"),
Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 2u, msg: ~"invalid syntax"}));
assert_eq!(from_str("faz"), assert_eq!(from_str("faz"),
Err(Error {line: 1u, col: 3u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 3u, msg: ~"invalid syntax"}));
assert_eq!(from_str("null"), Ok(Null)); assert_eq!(from_str("null"), Ok(Null));
assert_eq!(from_str("true"), Ok(Boolean(true))); assert_eq!(from_str("true"), Ok(Boolean(true)));
@ -1633,15 +1633,15 @@ mod tests {
#[test] #[test]
fn test_decode_identifiers() { fn test_decode_identifiers() {
let mut decoder = Decoder(from_str("null").unwrap()); let mut decoder = Decoder::init(from_str("null").unwrap());
let v: () = Decodable::decode(&mut decoder); let v: () = Decodable::decode(&mut decoder);
assert_eq!(v, ()); assert_eq!(v, ());
let mut decoder = Decoder(from_str("true").unwrap()); let mut decoder = Decoder::init(from_str("true").unwrap());
let v: bool = Decodable::decode(&mut decoder); let v: bool = Decodable::decode(&mut decoder);
assert_eq!(v, true); assert_eq!(v, true);
let mut decoder = Decoder(from_str("false").unwrap()); let mut decoder = Decoder::init(from_str("false").unwrap());
let v: bool = Decodable::decode(&mut decoder); let v: bool = Decodable::decode(&mut decoder);
assert_eq!(v, false); assert_eq!(v, false);
} }
@ -1649,20 +1649,20 @@ mod tests {
#[test] #[test]
fn test_read_number() { fn test_read_number() {
assert_eq!(from_str("+"), assert_eq!(from_str("+"),
Err(Error {line: 1u, col: 1u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 1u, msg: ~"invalid syntax"}));
assert_eq!(from_str("."), assert_eq!(from_str("."),
Err(Error {line: 1u, col: 1u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 1u, msg: ~"invalid syntax"}));
assert_eq!(from_str("-"), assert_eq!(from_str("-"),
Err(Error {line: 1u, col: 2u, msg: @~"invalid number"})); Err(Error {line: 1u, col: 2u, msg: ~"invalid number"}));
assert_eq!(from_str("00"), assert_eq!(from_str("00"),
Err(Error {line: 1u, col: 2u, msg: @~"invalid number"})); Err(Error {line: 1u, col: 2u, msg: ~"invalid number"}));
assert_eq!(from_str("1."), assert_eq!(from_str("1."),
Err(Error {line: 1u, col: 3u, msg: @~"invalid number"})); Err(Error {line: 1u, col: 3u, msg: ~"invalid number"}));
assert_eq!(from_str("1e"), assert_eq!(from_str("1e"),
Err(Error {line: 1u, col: 3u, msg: @~"invalid number"})); Err(Error {line: 1u, col: 3u, msg: ~"invalid number"}));
assert_eq!(from_str("1e+"), assert_eq!(from_str("1e+"),
Err(Error {line: 1u, col: 4u, msg: @~"invalid number"})); Err(Error {line: 1u, col: 4u, msg: ~"invalid number"}));
assert_eq!(from_str("3"), Ok(Number(3.0))); assert_eq!(from_str("3"), Ok(Number(3.0)));
assert_eq!(from_str("3.1"), Ok(Number(3.1))); assert_eq!(from_str("3.1"), Ok(Number(3.1)));
@ -1676,31 +1676,31 @@ mod tests {
#[test] #[test]
fn test_decode_numbers() { fn test_decode_numbers() {
let mut decoder = Decoder(from_str("3").unwrap()); let mut decoder = Decoder::init(from_str("3").unwrap());
let v: f64 = Decodable::decode(&mut decoder); let v: f64 = Decodable::decode(&mut decoder);
assert_eq!(v, 3.0); assert_eq!(v, 3.0);
let mut decoder = Decoder(from_str("3.1").unwrap()); let mut decoder = Decoder::init(from_str("3.1").unwrap());
let v: f64 = Decodable::decode(&mut decoder); let v: f64 = Decodable::decode(&mut decoder);
assert_eq!(v, 3.1); assert_eq!(v, 3.1);
let mut decoder = Decoder(from_str("-1.2").unwrap()); let mut decoder = Decoder::init(from_str("-1.2").unwrap());
let v: f64 = Decodable::decode(&mut decoder); let v: f64 = Decodable::decode(&mut decoder);
assert_eq!(v, -1.2); assert_eq!(v, -1.2);
let mut decoder = Decoder(from_str("0.4").unwrap()); let mut decoder = Decoder::init(from_str("0.4").unwrap());
let v: f64 = Decodable::decode(&mut decoder); let v: f64 = Decodable::decode(&mut decoder);
assert_eq!(v, 0.4); assert_eq!(v, 0.4);
let mut decoder = Decoder(from_str("0.4e5").unwrap()); let mut decoder = Decoder::init(from_str("0.4e5").unwrap());
let v: f64 = Decodable::decode(&mut decoder); let v: f64 = Decodable::decode(&mut decoder);
assert_eq!(v, 0.4e5); assert_eq!(v, 0.4e5);
let mut decoder = Decoder(from_str("0.4e15").unwrap()); let mut decoder = Decoder::init(from_str("0.4e15").unwrap());
let v: f64 = Decodable::decode(&mut decoder); let v: f64 = Decodable::decode(&mut decoder);
assert_eq!(v, 0.4e15); assert_eq!(v, 0.4e15);
let mut decoder = Decoder(from_str("0.4e-01").unwrap()); let mut decoder = Decoder::init(from_str("0.4e-01").unwrap());
let v: f64 = Decodable::decode(&mut decoder); let v: f64 = Decodable::decode(&mut decoder);
assert_eq!(v, 0.4e-01); assert_eq!(v, 0.4e-01);
} }
@ -1708,10 +1708,10 @@ mod tests {
#[test] #[test]
fn test_read_str() { fn test_read_str() {
assert_eq!(from_str("\""), assert_eq!(from_str("\""),
Err(Error {line: 1u, col: 2u, msg: @~"EOF while parsing string" Err(Error {line: 1u, col: 2u, msg: ~"EOF while parsing string"
})); }));
assert_eq!(from_str("\"lol"), assert_eq!(from_str("\"lol"),
Err(Error {line: 1u, col: 5u, msg: @~"EOF while parsing string" Err(Error {line: 1u, col: 5u, msg: ~"EOF while parsing string"
})); }));
assert_eq!(from_str("\"\""), Ok(String(~""))); assert_eq!(from_str("\"\""), Ok(String(~"")));
@ -1728,39 +1728,39 @@ mod tests {
#[test] #[test]
fn test_decode_str() { fn test_decode_str() {
let mut decoder = Decoder(from_str("\"\"").unwrap()); let mut decoder = Decoder::init(from_str("\"\"").unwrap());
let v: ~str = Decodable::decode(&mut decoder); let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~""); assert_eq!(v, ~"");
let mut decoder = Decoder(from_str("\"foo\"").unwrap()); let mut decoder = Decoder::init(from_str("\"foo\"").unwrap());
let v: ~str = Decodable::decode(&mut decoder); let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"foo"); assert_eq!(v, ~"foo");
let mut decoder = Decoder(from_str("\"\\\"\"").unwrap()); let mut decoder = Decoder::init(from_str("\"\\\"\"").unwrap());
let v: ~str = Decodable::decode(&mut decoder); let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"\""); assert_eq!(v, ~"\"");
let mut decoder = Decoder(from_str("\"\\b\"").unwrap()); let mut decoder = Decoder::init(from_str("\"\\b\"").unwrap());
let v: ~str = Decodable::decode(&mut decoder); let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"\x08"); assert_eq!(v, ~"\x08");
let mut decoder = Decoder(from_str("\"\\n\"").unwrap()); let mut decoder = Decoder::init(from_str("\"\\n\"").unwrap());
let v: ~str = Decodable::decode(&mut decoder); let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"\n"); assert_eq!(v, ~"\n");
let mut decoder = Decoder(from_str("\"\\r\"").unwrap()); let mut decoder = Decoder::init(from_str("\"\\r\"").unwrap());
let v: ~str = Decodable::decode(&mut decoder); let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"\r"); assert_eq!(v, ~"\r");
let mut decoder = Decoder(from_str("\"\\t\"").unwrap()); let mut decoder = Decoder::init(from_str("\"\\t\"").unwrap());
let v: ~str = Decodable::decode(&mut decoder); let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"\t"); assert_eq!(v, ~"\t");
let mut decoder = Decoder(from_str("\"\\u12ab\"").unwrap()); let mut decoder = Decoder::init(from_str("\"\\u12ab\"").unwrap());
let v: ~str = Decodable::decode(&mut decoder); let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"\u12ab"); assert_eq!(v, ~"\u12ab");
let mut decoder = Decoder(from_str("\"\\uAB12\"").unwrap()); let mut decoder = Decoder::init(from_str("\"\\uAB12\"").unwrap());
let v: ~str = Decodable::decode(&mut decoder); let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"\uAB12"); assert_eq!(v, ~"\uAB12");
} }
@ -1768,15 +1768,15 @@ mod tests {
#[test] #[test]
fn test_read_list() { fn test_read_list() {
assert_eq!(from_str("["), assert_eq!(from_str("["),
Err(Error {line: 1u, col: 2u, msg: @~"EOF while parsing value"})); Err(Error {line: 1u, col: 2u, msg: ~"EOF while parsing value"}));
assert_eq!(from_str("[1"), assert_eq!(from_str("[1"),
Err(Error {line: 1u, col: 3u, msg: @~"EOF while parsing list"})); Err(Error {line: 1u, col: 3u, msg: ~"EOF while parsing list"}));
assert_eq!(from_str("[1,"), assert_eq!(from_str("[1,"),
Err(Error {line: 1u, col: 4u, msg: @~"EOF while parsing value"})); Err(Error {line: 1u, col: 4u, msg: ~"EOF while parsing value"}));
assert_eq!(from_str("[1,]"), assert_eq!(from_str("[1,]"),
Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 4u, msg: ~"invalid syntax"}));
assert_eq!(from_str("[6 7]"), assert_eq!(from_str("[6 7]"),
Err(Error {line: 1u, col: 4u, msg: @~"expected `,` or `]`"})); Err(Error {line: 1u, col: 4u, msg: ~"expected `,` or `]`"}));
assert_eq!(from_str("[]"), Ok(List(~[]))); assert_eq!(from_str("[]"), Ok(List(~[])));
assert_eq!(from_str("[ ]"), Ok(List(~[]))); assert_eq!(from_str("[ ]"), Ok(List(~[])));
@ -1793,27 +1793,27 @@ mod tests {
#[test] #[test]
fn test_decode_list() { fn test_decode_list() {
let mut decoder = Decoder(from_str("[]").unwrap()); let mut decoder = Decoder::init(from_str("[]").unwrap());
let v: ~[()] = Decodable::decode(&mut decoder); let v: ~[()] = Decodable::decode(&mut decoder);
assert_eq!(v, ~[]); assert_eq!(v, ~[]);
let mut decoder = Decoder(from_str("[null]").unwrap()); let mut decoder = Decoder::init(from_str("[null]").unwrap());
let v: ~[()] = Decodable::decode(&mut decoder); let v: ~[()] = Decodable::decode(&mut decoder);
assert_eq!(v, ~[()]); assert_eq!(v, ~[()]);
let mut decoder = Decoder(from_str("[true]").unwrap()); let mut decoder = Decoder::init(from_str("[true]").unwrap());
let v: ~[bool] = Decodable::decode(&mut decoder); let v: ~[bool] = Decodable::decode(&mut decoder);
assert_eq!(v, ~[true]); assert_eq!(v, ~[true]);
let mut decoder = Decoder(from_str("[true]").unwrap()); let mut decoder = Decoder::init(from_str("[true]").unwrap());
let v: ~[bool] = Decodable::decode(&mut decoder); let v: ~[bool] = Decodable::decode(&mut decoder);
assert_eq!(v, ~[true]); assert_eq!(v, ~[true]);
let mut decoder = Decoder(from_str("[3, 1]").unwrap()); let mut decoder = Decoder::init(from_str("[3, 1]").unwrap());
let v: ~[int] = Decodable::decode(&mut decoder); let v: ~[int] = Decodable::decode(&mut decoder);
assert_eq!(v, ~[3, 1]); assert_eq!(v, ~[3, 1]);
let mut decoder = Decoder(from_str("[[3], [1, 2]]").unwrap()); let mut decoder = Decoder::init(from_str("[[3], [1, 2]]").unwrap());
let v: ~[~[uint]] = Decodable::decode(&mut decoder); let v: ~[~[uint]] = Decodable::decode(&mut decoder);
assert_eq!(v, ~[~[3], ~[1, 2]]); assert_eq!(v, ~[~[3], ~[1, 2]]);
} }
@ -1824,49 +1824,49 @@ mod tests {
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 2u, col: 2u,
msg: @~"EOF while parsing object"})); msg: ~"EOF while parsing object"}));
assert_eq!(from_str("{ "), assert_eq!(from_str("{ "),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 3u, col: 3u,
msg: @~"EOF while parsing object"})); msg: ~"EOF while parsing object"}));
assert_eq!(from_str("{1"), assert_eq!(from_str("{1"),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 2u, col: 2u,
msg: @~"key must be a string"})); msg: ~"key must be a string"}));
assert_eq!(from_str("{ \"a\""), assert_eq!(from_str("{ \"a\""),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 6u, col: 6u,
msg: @~"EOF while parsing object"})); msg: ~"EOF while parsing object"}));
assert_eq!(from_str("{\"a\""), assert_eq!(from_str("{\"a\""),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 5u, col: 5u,
msg: @~"EOF while parsing object"})); msg: ~"EOF while parsing object"}));
assert_eq!(from_str("{\"a\" "), assert_eq!(from_str("{\"a\" "),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 6u, col: 6u,
msg: @~"EOF while parsing object"})); msg: ~"EOF while parsing object"}));
assert_eq!(from_str("{\"a\" 1"), assert_eq!(from_str("{\"a\" 1"),
Err(Error {line: 1u, col: 6u, msg: @~"expected `:`"})); Err(Error {line: 1u, col: 6u, msg: ~"expected `:`"}));
assert_eq!(from_str("{\"a\":"), assert_eq!(from_str("{\"a\":"),
Err(Error {line: 1u, col: 6u, msg: @~"EOF while parsing value"})); Err(Error {line: 1u, col: 6u, msg: ~"EOF while parsing value"}));
assert_eq!(from_str("{\"a\":1"), assert_eq!(from_str("{\"a\":1"),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 7u, col: 7u,
msg: @~"EOF while parsing object"})); msg: ~"EOF while parsing object"}));
assert_eq!(from_str("{\"a\":1 1"), assert_eq!(from_str("{\"a\":1 1"),
Err(Error {line: 1u, col: 8u, msg: @~"expected `,` or `}`"})); Err(Error {line: 1u, col: 8u, msg: ~"expected `,` or `}`"}));
assert_eq!(from_str("{\"a\":1,"), assert_eq!(from_str("{\"a\":1,"),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 8u, col: 8u,
msg: @~"EOF while parsing object"})); msg: ~"EOF while parsing object"}));
assert_eq!(from_str("{}").unwrap(), mk_object([])); assert_eq!(from_str("{}").unwrap(), mk_object([]));
assert_eq!(from_str("{\"a\": 3}").unwrap(), assert_eq!(from_str("{\"a\": 3}").unwrap(),
@ -1915,7 +1915,7 @@ mod tests {
{ \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] } { \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] }
] ]
}"; }";
let mut decoder = Decoder(from_str(s).unwrap()); let mut decoder = Decoder::init(from_str(s).unwrap());
let v: Outer = Decodable::decode(&mut decoder); let v: Outer = Decodable::decode(&mut decoder);
assert_eq!( assert_eq!(
v, v,
@ -1929,23 +1929,23 @@ mod tests {
#[test] #[test]
fn test_decode_option() { fn test_decode_option() {
let mut decoder = Decoder(from_str("null").unwrap()); let mut decoder = Decoder::init(from_str("null").unwrap());
let value: Option<~str> = Decodable::decode(&mut decoder); let value: Option<~str> = Decodable::decode(&mut decoder);
assert_eq!(value, None); assert_eq!(value, None);
let mut decoder = Decoder(from_str("\"jodhpurs\"").unwrap()); let mut decoder = Decoder::init(from_str("\"jodhpurs\"").unwrap());
let value: Option<~str> = Decodable::decode(&mut decoder); let value: Option<~str> = Decodable::decode(&mut decoder);
assert_eq!(value, Some(~"jodhpurs")); assert_eq!(value, Some(~"jodhpurs"));
} }
#[test] #[test]
fn test_decode_enum() { fn test_decode_enum() {
let mut decoder = Decoder(from_str("\"Dog\"").unwrap()); let mut decoder = Decoder::init(from_str("\"Dog\"").unwrap());
let value: Animal = Decodable::decode(&mut decoder); let value: Animal = Decodable::decode(&mut decoder);
assert_eq!(value, Dog); assert_eq!(value, Dog);
let mut decoder = let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}";
Decoder(from_str("{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}").unwrap()); let mut decoder = Decoder::init(from_str(s).unwrap());
let value: Animal = Decodable::decode(&mut decoder); let value: Animal = Decodable::decode(&mut decoder);
assert_eq!(value, Frog(~"Henry", 349)); assert_eq!(value, Frog(~"Henry", 349));
} }
@ -1953,7 +1953,7 @@ mod tests {
#[test] #[test]
fn test_decode_map() { fn test_decode_map() {
let s = ~"{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\"fields\":[\"Henry\", 349]}}"; let s = ~"{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\"fields\":[\"Henry\", 349]}}";
let mut decoder = Decoder(from_str(s).unwrap()); let mut decoder = Decoder::init(from_str(s).unwrap());
let mut map: TreeMap<~str, Animal> = Decodable::decode(&mut decoder); let mut map: TreeMap<~str, Animal> = Decodable::decode(&mut decoder);
assert_eq!(map.pop(&~"a"), Some(Dog)); assert_eq!(map.pop(&~"a"), Some(Dog));
@ -1966,7 +1966,7 @@ mod tests {
Err(Error { Err(Error {
line: 3u, line: 3u,
col: 8u, col: 8u,
msg: @~"EOF while parsing object"})); msg: ~"EOF while parsing object"}));
} }
#[deriving(Decodable)] #[deriving(Decodable)]
@ -1990,7 +1990,7 @@ mod tests {
match from_str(to_parse) { match from_str(to_parse) {
Err(e) => Some(e.to_str()), Err(e) => Some(e.to_str()),
Ok(json) => { Ok(json) => {
let _: T = Decodable::decode(&mut Decoder(json)); let _: T = Decodable::decode(&mut Decoder::init(json));
None None
} }
} }

5
src/libextra/test.rs
View File

@ -945,8 +945,9 @@ impl MetricMap {
/// Load MetricDiff from a file. /// Load MetricDiff from a file.
pub fn load(p: &Path) -> MetricMap { pub fn load(p: &Path) -> MetricMap {
assert!(p.exists()); assert!(p.exists());
let f = @mut File::open(p) as @mut io::Reader; let mut f = File::open(p);
let mut decoder = json::Decoder(json::from_reader(f).unwrap()); let value = json::from_reader(&mut f as &mut io::Reader).unwrap();
let mut decoder = json::Decoder::init(value);
MetricMap(Decodable::decode(&mut decoder)) MetricMap(Decodable::decode(&mut decoder))
} }

20
src/libextra/workcache.rs
View File

@ -191,7 +191,7 @@ impl Database {
Err(e) => fail!("Couldn't parse workcache database (from file {}): {}", Err(e) => fail!("Couldn't parse workcache database (from file {}): {}",
self.db_filename.display(), e.to_str()), self.db_filename.display(), e.to_str()),
Ok(r) => { Ok(r) => {
let mut decoder = json::Decoder(r); let mut decoder = json::Decoder::init(r);
self.db_cache = Decodable::decode(&mut decoder); self.db_cache = Decodable::decode(&mut decoder);
} }
} }
@ -256,9 +256,9 @@ enum Work<'self, T> {
WorkFromTask(&'self Prep<'self>, PortOne<(Exec, T)>), WorkFromTask(&'self Prep<'self>, PortOne<(Exec, T)>),
} }
fn json_encode<T:Encodable<json::Encoder>>(t: &T) -> ~str { fn json_encode<'self, T:Encodable<json::Encoder<'self>>>(t: &T) -> ~str {
let writer = @mut MemWriter::new(); let mut writer = MemWriter::new();
let mut encoder = json::Encoder(writer as @mut io::Writer); let mut encoder = json::Encoder::init(&mut writer as &mut io::Writer);
t.encode(&mut encoder); t.encode(&mut encoder);
str::from_utf8(writer.inner_ref().as_slice()) str::from_utf8(writer.inner_ref().as_slice())
} }
@ -267,7 +267,7 @@ fn json_encode<T:Encodable<json::Encoder>>(t: &T) -> ~str {
fn json_decode<T:Decodable<json::Decoder>>(s: &str) -> T { fn json_decode<T:Decodable<json::Decoder>>(s: &str) -> T {
debug!("json decoding: {}", s); debug!("json decoding: {}", s);
let j = json::from_str(s).unwrap(); let j = json::from_str(s).unwrap();
let mut decoder = json::Decoder(j); let mut decoder = json::Decoder::init(j);
Decodable::decode(&mut decoder) Decodable::decode(&mut decoder)
} }
@ -396,15 +396,15 @@ impl<'self> Prep<'self> {
return true; return true;
} }
pub fn exec<T:Send + pub fn exec<'self, T:Send +
Encodable<json::Encoder> + Encodable<json::Encoder<'self>> +
Decodable<json::Decoder>>( Decodable<json::Decoder>>(
&'self self, blk: proc(&mut Exec) -> T) -> T { &'self self, blk: proc(&mut Exec) -> T) -> T {
self.exec_work(blk).unwrap() self.exec_work(blk).unwrap()
} }
fn exec_work<T:Send + fn exec_work<'self, T:Send +
Encodable<json::Encoder> + Encodable<json::Encoder<'self>> +
Decodable<json::Decoder>>( // FIXME(#5121) Decodable<json::Decoder>>( // FIXME(#5121)
&'self self, blk: proc(&mut Exec) -> T) -> Work<'self, T> { &'self self, blk: proc(&mut Exec) -> T) -> Work<'self, T> {
let mut bo = Some(blk); let mut bo = Some(blk);
@ -449,7 +449,7 @@ impl<'self> Prep<'self> {
} }
impl<'self, T:Send + impl<'self, T:Send +
Encodable<json::Encoder> + Encodable<json::Encoder<'self>> +
Decodable<json::Decoder>> Decodable<json::Decoder>>
Work<'self, T> { // FIXME(#5121) Work<'self, T> { // FIXME(#5121)

11
src/librustdoc/lib.rs
View File

@ -283,7 +283,7 @@ fn json_input(input: &str) -> Result<Output, ~str> {
} }
let crate = match obj.pop(&~"crate") { let crate = match obj.pop(&~"crate") {
Some(json) => { Some(json) => {
let mut d = json::Decoder(json); let mut d = json::Decoder::init(json);
Decodable::decode(&mut d) Decodable::decode(&mut d)
} }
None => return Err(~"malformed json"), None => return Err(~"malformed json"),
@ -312,9 +312,12 @@ fn json_output(crate: clean::Crate, res: ~[plugins::PluginJson], dst: Path) {
// FIXME #8335: yuck, Rust -> str -> JSON round trip! No way to .encode // FIXME #8335: yuck, Rust -> str -> JSON round trip! No way to .encode
// straight to the Rust JSON representation. // straight to the Rust JSON representation.
let crate_json_str = { let crate_json_str = {
let w = @mut MemWriter::new(); let mut w = MemWriter::new();
crate.encode(&mut json::Encoder(w as @mut io::Writer)); {
str::from_utf8(*w.inner_ref()) let mut encoder = json::Encoder::init(&mut w as &mut io::Writer);
crate.encode(&mut encoder);
}
str::from_utf8_owned(w.inner())
}; };
let crate_json = match json::from_str(crate_json_str) { let crate_json = match json::from_str(crate_json_str) {
Ok(j) => j, Ok(j) => j,

9
src/libsyntax/parse/mod.rs
View File

@ -341,11 +341,12 @@ mod test {
use util::parser_testing::{string_to_expr, string_to_item}; use util::parser_testing::{string_to_expr, string_to_item};
use util::parser_testing::string_to_stmt; use util::parser_testing::string_to_stmt;
#[cfg(test)] fn to_json_str<E : Encodable<extra::json::Encoder>>(val: @E) -> ~str { #[cfg(test)]
let writer = @mut MemWriter::new(); fn to_json_str<'a, E: Encodable<extra::json::Encoder<'a>>>(val: &E) -> ~str {
let mut encoder = extra::json::Encoder(writer as @mut io::Writer); let mut writer = MemWriter::new();
let mut encoder = extra::json::Encoder::init(&mut writer as &mut io::Writer);
val.encode(&mut encoder); val.encode(&mut encoder);
str::from_utf8(*writer.inner_ref()) str::from_utf8_owned(writer.inner())
} }
// produce a codemap::span // produce a codemap::span

2
src/test/run-pass/issue-4016.rs
View File

@ -18,7 +18,7 @@ trait JD : Decodable<json::Decoder> { }
fn exec<T: JD>() { fn exec<T: JD>() {
let doc = json::from_str("").unwrap(); let doc = json::from_str("").unwrap();
let mut decoder = json::Decoder(doc); let mut decoder = json::Decoder::init(doc);
let _v: T = Decodable::decode(&mut decoder); let _v: T = Decodable::decode(&mut decoder);
fail!() fail!()
} }

2
src/test/run-pass/issue-4036.rs
View File

@ -17,6 +17,6 @@ use self::extra::serialize;
pub fn main() { pub fn main() {
let json = json::from_str("[1]").unwrap(); let json = json::from_str("[1]").unwrap();
let mut decoder = json::Decoder(json); let mut decoder = json::Decoder::init(json);
let _x: ~[int] = serialize::Decodable::decode(&mut decoder); let _x: ~[int] = serialize::Decodable::decode(&mut decoder);
} }