bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

extra: json::Encoder should take a &mut io::Writer

Browse source
This commit is contained in:
Erick Tryzelaar 2013-11-29 10:12:08 -08:00
parent f7b739c34c
commit 6818b96a66
3 changed files with 62 additions and 61 deletions
Download patch file Download diff file Expand all files Collapse all files

100
src/libextra/json.rs
View file

@ -84,19 +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,
} }
impl Encoder { impl<'self> Encoder<'self> {
/// Creates a new JSON encoder whose output will be written to the writer /// Creates a new JSON encoder whose output will be written to the writer
/// specified. /// specified.
pub fn init(wr: @mut io::Writer) -> Encoder { pub fn init<'a>(wr: &'a mut io::Writer) -> Encoder<'a> {
Encoder { wr: wr } 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); }
@ -129,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"]}
@ -150,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, ",");
} }
@ -161,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"\}");
@ -181,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)
} }
@ -240,14 +240,14 @@ 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,
} }
impl PrettyEncoder { impl<'self> PrettyEncoder<'self> {
/// Creates a new encoder whose output will be written to the specified writer /// Creates a new encoder whose output will be written to the specified writer
pub fn init(wr: @mut io::Writer) -> PrettyEncoder { pub fn init<'a>(wr: &'a mut io::Writer) -> PrettyEncoder<'a> {
PrettyEncoder { PrettyEncoder {
wr: wr, wr: wr,
indent: 0, indent: 0,
@ -255,7 +255,7 @@ impl PrettyEncoder {
} }
} }
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); }
@ -286,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)
} }
@ -294,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 {
@ -308,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");
} }
@ -320,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)
} }
@ -335,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 {
@ -350,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 {
@ -360,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 {
@ -395,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 {
@ -405,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 {
@ -417,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 {
@ -427,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);
} }
@ -448,22 +448,22 @@ 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::init(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::init(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(s.inner_ref().as_slice())
} }
} }

16
src/libextra/workcache.rs
View file

@ -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::init(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())
} }
@ -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)

7
src/libsyntax/parse/mod.rs
View file

@ -341,9 +341,10 @@ 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::init(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(*writer.inner_ref())
} }