Register snapshots
This commit is contained in:
Brian Anderson
parent
b872900a5b
commit
8081e8debf
47 changed files with 16 additions and 5720 deletions
|
|
@ -77,150 +77,6 @@ pub fn Encoder(wr: @io::Writer) -> Encoder {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(stage0)]
|
||||
impl serialize::Encoder for Encoder {
|
||||
fn emit_nil(&self) { self.wr.write_str("null") }
|
||||
|
||||
fn emit_uint(&self, v: uint) { self.emit_float(v as float); }
|
||||
fn emit_u64(&self, v: u64) { self.emit_float(v as float); }
|
||||
fn emit_u32(&self, v: u32) { self.emit_float(v as float); }
|
||||
fn emit_u16(&self, v: u16) { self.emit_float(v as float); }
|
||||
fn emit_u8(&self, v: u8) { self.emit_float(v as float); }
|
||||
|
||||
fn emit_int(&self, v: int) { self.emit_float(v as float); }
|
||||
fn emit_i64(&self, v: i64) { self.emit_float(v as float); }
|
||||
fn emit_i32(&self, v: i32) { self.emit_float(v as float); }
|
||||
fn emit_i16(&self, v: i16) { self.emit_float(v as float); }
|
||||
fn emit_i8(&self, v: i8) { self.emit_float(v as float); }
|
||||
|
||||
fn emit_bool(&self, v: bool) {
|
||||
if v {
|
||||
self.wr.write_str("true");
|
||||
} else {
|
||||
self.wr.write_str("false");
|
||||
}
|
||||
}
|
||||
|
||||
fn emit_f64(&self, v: f64) { self.emit_float(v as float); }
|
||||
fn emit_f32(&self, v: f32) { self.emit_float(v as float); }
|
||||
fn emit_float(&self, v: float) {
|
||||
self.wr.write_str(float::to_str_digits(v, 6u));
|
||||
}
|
||||
|
||||
fn emit_char(&self, v: char) { self.emit_str(str::from_char(v)) }
|
||||
fn emit_str(&self, v: &str) { self.wr.write_str(escape_str(v)) }
|
||||
|
||||
fn emit_enum(&self, _name: &str, f: &fn()) { f() }
|
||||
|
||||
fn emit_enum_variant(&self,
|
||||
name: &str,
|
||||
_id: uint,
|
||||
cnt: uint,
|
||||
f: &fn()) {
|
||||
// enums are encoded as strings or vectors:
|
||||
// Bunny => "Bunny"
|
||||
// Kangaroo(34,"William") => ["Kangaroo",[34,"William"]]
|
||||
|
||||
if cnt == 0 {
|
||||
self.wr.write_str(escape_str(name));
|
||||
} else {
|
||||
self.wr.write_char('[');
|
||||
self.wr.write_str(escape_str(name));
|
||||
self.wr.write_char(',');
|
||||
f();
|
||||
self.wr.write_char(']');
|
||||
}
|
||||
}
|
||||
|
||||
fn emit_enum_variant_arg(&self, idx: uint, f: &fn()) {
|
||||
if idx != 0 {self.wr.write_char(',');}
|
||||
f();
|
||||
}
|
||||
|
||||
fn emit_enum_struct_variant(&self,
|
||||
name: &str,
|
||||
id: uint,
|
||||
cnt: uint,
|
||||
f: &fn()) {
|
||||
self.emit_enum_variant(name, id, cnt, f)
|
||||
}
|
||||
|
||||
fn emit_enum_struct_variant_field(&self,
|
||||
_: &str,
|
||||
idx: uint,
|
||||
f: &fn()) {
|
||||
self.emit_enum_variant_arg(idx, f)
|
||||
}
|
||||
|
||||
fn emit_struct(&self, _: &str, _: uint, f: &fn()) {
|
||||
self.wr.write_char('{');
|
||||
f();
|
||||
self.wr.write_char('}');
|
||||
}
|
||||
|
||||
#[cfg(stage0)]
|
||||
fn emit_field(&self, name: &str, idx: uint, f: &fn()) {
|
||||
if idx != 0 { self.wr.write_char(','); }
|
||||
self.wr.write_str(escape_str(name));
|
||||
self.wr.write_char(':');
|
||||
f();
|
||||
}
|
||||
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
#[cfg(stage3)]
|
||||
fn emit_struct_field(&self, name: &str, idx: uint, f: &fn()) {
|
||||
if idx != 0 { self.wr.write_char(','); }
|
||||
self.wr.write_str(escape_str(name));
|
||||
self.wr.write_char(':');
|
||||
f();
|
||||
}
|
||||
|
||||
fn emit_tuple(&self, len: uint, f: &fn()) { self.emit_seq(len, f) }
|
||||
fn emit_tuple_arg(&self, idx: uint, f: &fn()) {
|
||||
self.emit_seq_elt(idx, f)
|
||||
}
|
||||
|
||||
fn emit_tuple_struct(&self, _name: &str, len: uint, f: &fn()) {
|
||||
self.emit_seq(len, f)
|
||||
}
|
||||
fn emit_tuple_struct_arg(&self, idx: uint, f: &fn()) {
|
||||
self.emit_seq_elt(idx, f)
|
||||
}
|
||||
|
||||
fn emit_option(&self, f: &fn()) { f(); }
|
||||
fn emit_option_none(&self) { self.emit_nil(); }
|
||||
fn emit_option_some(&self, f: &fn()) { f(); }
|
||||
|
||||
fn emit_seq(&self, _len: uint, f: &fn()) {
|
||||
self.wr.write_char('[');
|
||||
f();
|
||||
self.wr.write_char(']');
|
||||
}
|
||||
|
||||
fn emit_seq_elt(&self, idx: uint, f: &fn()) {
|
||||
if idx != 0 { self.wr.write_char(','); }
|
||||
f()
|
||||
}
|
||||
|
||||
fn emit_map(&self, _len: uint, f: &fn()) {
|
||||
self.wr.write_char('{');
|
||||
f();
|
||||
self.wr.write_char('}');
|
||||
}
|
||||
|
||||
fn emit_map_elt_key(&self, idx: uint, f: &fn()) {
|
||||
if idx != 0 { self.wr.write_char(','); }
|
||||
f()
|
||||
}
|
||||
|
||||
fn emit_map_elt_val(&self, _idx: uint, f: &fn()) {
|
||||
self.wr.write_char(':');
|
||||
f()
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(stage0))]
|
||||
impl serialize::Encoder for Encoder {
|
||||
fn emit_nil(&mut self) { self.wr.write_str("null") }
|
||||
|
||||
|
|
@ -376,202 +232,6 @@ pub fn PrettyEncoder(wr: @io::Writer) -> PrettyEncoder {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(stage0)]
|
||||
impl serialize::Encoder for PrettyEncoder {
|
||||
fn emit_nil(&self) { self.wr.write_str("null") }
|
||||
|
||||
fn emit_uint(&self, v: uint) { self.emit_float(v as float); }
|
||||
fn emit_u64(&self, v: u64) { self.emit_float(v as float); }
|
||||
fn emit_u32(&self, v: u32) { self.emit_float(v as float); }
|
||||
fn emit_u16(&self, v: u16) { self.emit_float(v as float); }
|
||||
fn emit_u8(&self, v: u8) { self.emit_float(v as float); }
|
||||
|
||||
fn emit_int(&self, v: int) { self.emit_float(v as float); }
|
||||
fn emit_i64(&self, v: i64) { self.emit_float(v as float); }
|
||||
fn emit_i32(&self, v: i32) { self.emit_float(v as float); }
|
||||
fn emit_i16(&self, v: i16) { self.emit_float(v as float); }
|
||||
fn emit_i8(&self, v: i8) { self.emit_float(v as float); }
|
||||
|
||||
fn emit_bool(&self, v: bool) {
|
||||
if v {
|
||||
self.wr.write_str("true");
|
||||
} else {
|
||||
self.wr.write_str("false");
|
||||
}
|
||||
}
|
||||
|
||||
fn emit_f64(&self, v: f64) { self.emit_float(v as float); }
|
||||
fn emit_f32(&self, v: f32) { self.emit_float(v as float); }
|
||||
fn emit_float(&self, v: float) {
|
||||
self.wr.write_str(float::to_str_digits(v, 6u));
|
||||
}
|
||||
|
||||
fn emit_char(&self, v: char) { self.emit_str(str::from_char(v)) }
|
||||
fn emit_str(&self, v: &str) { self.wr.write_str(escape_str(v)); }
|
||||
|
||||
fn emit_enum(&self, _name: &str, f: &fn()) { f() }
|
||||
|
||||
fn emit_enum_variant(&self,
|
||||
name: &str,
|
||||
_: uint,
|
||||
cnt: uint,
|
||||
f: &fn()) {
|
||||
if cnt == 0 {
|
||||
self.wr.write_str(escape_str(name));
|
||||
} else {
|
||||
self.wr.write_char('[');
|
||||
self.indent += 2;
|
||||
self.wr.write_char('\n');
|
||||
self.wr.write_str(spaces(self.indent));
|
||||
self.wr.write_str(escape_str(name));
|
||||
self.wr.write_str(",\n");
|
||||
f();
|
||||
self.wr.write_char('\n');
|
||||
self.indent -= 2;
|
||||
self.wr.write_str(spaces(self.indent));
|
||||
self.wr.write_char(']');
|
||||
}
|
||||
}
|
||||
|
||||
fn emit_enum_variant_arg(&self, idx: uint, f: &fn()) {
|
||||
if idx != 0 {
|
||||
self.wr.write_str(",\n");
|
||||
}
|
||||
self.wr.write_str(spaces(self.indent));
|
||||
f()
|
||||
}
|
||||
|
||||
fn emit_enum_struct_variant(&self,
|
||||
name: &str,
|
||||
id: uint,
|
||||
cnt: uint,
|
||||
f: &fn()) {
|
||||
self.emit_enum_variant(name, id, cnt, f)
|
||||
}
|
||||
|
||||
fn emit_enum_struct_variant_field(&self,
|
||||
_: &str,
|
||||
idx: uint,
|
||||
f: &fn()) {
|
||||
self.emit_enum_variant_arg(idx, f)
|
||||
}
|
||||
|
||||
|
||||
fn emit_struct(&self, _name: &str, len: uint, f: &fn()) {
|
||||
if len == 0 {
|
||||
self.wr.write_str("{}");
|
||||
} else {
|
||||
self.wr.write_char('{');
|
||||
self.indent += 2;
|
||||
f();
|
||||
self.wr.write_char('\n');
|
||||
self.indent -= 2;
|
||||
self.wr.write_str(spaces(self.indent));
|
||||
self.wr.write_char('}');
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(stage0)]
|
||||
fn emit_field(&self, name: &str, idx: uint, f: &fn()) {
|
||||
if idx == 0 {
|
||||
self.wr.write_char('\n');
|
||||
} else {
|
||||
self.wr.write_str(",\n");
|
||||
}
|
||||
self.wr.write_str(spaces(self.indent));
|
||||
self.wr.write_str(escape_str(name));
|
||||
self.wr.write_str(": ");
|
||||
f();
|
||||
}
|
||||
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
#[cfg(stage3)]
|
||||
fn emit_struct_field(&self, name: &str, idx: uint, f: &fn()) {
|
||||
if idx == 0 {
|
||||
self.wr.write_char('\n');
|
||||
} else {
|
||||
self.wr.write_str(",\n");
|
||||
}
|
||||
self.wr.write_str(spaces(self.indent));
|
||||
self.wr.write_str(escape_str(name));
|
||||
self.wr.write_str(": ");
|
||||
f();
|
||||
}
|
||||
|
||||
fn emit_tuple(&self, len: uint, f: &fn()) {
|
||||
self.emit_seq(len, f)
|
||||
}
|
||||
fn emit_tuple_arg(&self, idx: uint, f: &fn()) {
|
||||
self.emit_seq_elt(idx, f)
|
||||
}
|
||||
|
||||
fn emit_tuple_struct(&self, _name: &str, len: uint, f: &fn()) {
|
||||
self.emit_seq(len, f)
|
||||
}
|
||||
fn emit_tuple_struct_arg(&self, idx: uint, f: &fn()) {
|
||||
self.emit_seq_elt(idx, f)
|
||||
}
|
||||
|
||||
fn emit_option(&self, f: &fn()) { f(); }
|
||||
fn emit_option_none(&self) { self.emit_nil(); }
|
||||
fn emit_option_some(&self, f: &fn()) { f(); }
|
||||
|
||||
fn emit_seq(&self, len: uint, f: &fn()) {
|
||||
if len == 0 {
|
||||
self.wr.write_str("[]");
|
||||
} else {
|
||||
self.wr.write_char('[');
|
||||
self.indent += 2;
|
||||
f();
|
||||
self.wr.write_char('\n');
|
||||
self.indent -= 2;
|
||||
self.wr.write_str(spaces(self.indent));
|
||||
self.wr.write_char(']');
|
||||
}
|
||||
}
|
||||
|
||||
fn emit_seq_elt(&self, idx: uint, f: &fn()) {
|
||||
if idx == 0 {
|
||||
self.wr.write_char('\n');
|
||||
} else {
|
||||
self.wr.write_str(",\n");
|
||||
}
|
||||
self.wr.write_str(spaces(self.indent));
|
||||
f()
|
||||
}
|
||||
|
||||
fn emit_map(&self, len: uint, f: &fn()) {
|
||||
if len == 0 {
|
||||
self.wr.write_str("{}");
|
||||
} else {
|
||||
self.wr.write_char('{');
|
||||
self.indent += 2;
|
||||
f();
|
||||
self.wr.write_char('\n');
|
||||
self.indent -= 2;
|
||||
self.wr.write_str(spaces(self.indent));
|
||||
self.wr.write_char('}');
|
||||
}
|
||||
}
|
||||
|
||||
fn emit_map_elt_key(&self, idx: uint, f: &fn()) {
|
||||
if idx == 0 {
|
||||
self.wr.write_char('\n');
|
||||
} else {
|
||||
self.wr.write_str(",\n");
|
||||
}
|
||||
self.wr.write_str(spaces(self.indent));
|
||||
f();
|
||||
}
|
||||
|
||||
fn emit_map_elt_val(&self, _idx: uint, f: &fn()) {
|
||||
self.wr.write_str(": ");
|
||||
f();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(stage0))]
|
||||
impl serialize::Encoder for PrettyEncoder {
|
||||
fn emit_nil(&mut self) { self.wr.write_str("null") }
|
||||
|
||||
|
|
@ -765,21 +425,6 @@ impl serialize::Encoder for PrettyEncoder {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(stage0)]
|
||||
impl<E: serialize::Encoder> serialize::Encodable<E> for Json {
|
||||
fn encode(&self, e: &E) {
|
||||
match *self {
|
||||
Number(v) => v.encode(e),
|
||||
String(ref v) => v.encode(e),
|
||||
Boolean(v) => v.encode(e),
|
||||
List(ref v) => v.encode(e),
|
||||
Object(ref v) => v.encode(e),
|
||||
Null => e.emit_nil(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(stage0))]
|
||||
impl<E: serialize::Encoder> serialize::Encodable<E> for Json {
|
||||
fn encode(&self, e: &mut E) {
|
||||
match *self {
|
||||
|
|
@ -794,14 +439,6 @@ impl<E: serialize::Encoder> serialize::Encodable<E> for Json {
|
|||
}
|
||||
|
||||
/// Encodes a json value into a io::writer
|
||||
#[cfg(stage0)]
|
||||
pub fn to_writer(wr: @io::Writer, json: &Json) {
|
||||
let encoder = Encoder(wr);
|
||||
json.encode(&encoder)
|
||||
}
|
||||
|
||||
/// Encodes a json value into a io::writer
|
||||
#[cfg(not(stage0))]
|
||||
pub fn to_writer(wr: @io::Writer, json: &Json) {
|
||||
let mut encoder = Encoder(wr);
|
||||
json.encode(&mut encoder)
|
||||
|
|
@ -813,14 +450,6 @@ pub fn to_str(json: &Json) -> ~str {
|
|||
}
|
||||
|
||||
/// Encodes a json value into a io::writer
|
||||
#[cfg(stage0)]
|
||||
pub fn to_pretty_writer(wr: @io::Writer, json: &Json) {
|
||||
let encoder = PrettyEncoder(wr);
|
||||
json.encode(&encoder)
|
||||
}
|
||||
|
||||
/// Encodes a json value into a io::writer
|
||||
#[cfg(not(stage0))]
|
||||
pub fn to_pretty_writer(wr: @io::Writer, json: &Json) {
|
||||
let mut encoder = PrettyEncoder(wr);
|
||||
json.encode(&mut encoder)
|
||||
|
|
@ -1219,243 +848,6 @@ pub fn Decoder(json: Json) -> Decoder {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(stage0)]
|
||||
impl serialize::Decoder for Decoder {
|
||||
fn read_nil(&self) -> () {
|
||||
debug!("read_nil");
|
||||
match self.stack.pop() {
|
||||
Null => (),
|
||||
value => fail!(fmt!("not a null: %?", value))
|
||||
}
|
||||
}
|
||||
|
||||
fn read_u64(&self) -> u64 { self.read_float() as u64 }
|
||||
fn read_u32(&self) -> u32 { self.read_float() as u32 }
|
||||
fn read_u16(&self) -> u16 { self.read_float() as u16 }
|
||||
fn read_u8 (&self) -> u8 { self.read_float() as u8 }
|
||||
fn read_uint(&self) -> uint { self.read_float() as uint }
|
||||
|
||||
fn read_i64(&self) -> i64 { self.read_float() as i64 }
|
||||
fn read_i32(&self) -> i32 { self.read_float() as i32 }
|
||||
fn read_i16(&self) -> i16 { self.read_float() as i16 }
|
||||
fn read_i8 (&self) -> i8 { self.read_float() as i8 }
|
||||
fn read_int(&self) -> int { self.read_float() as int }
|
||||
|
||||
fn read_bool(&self) -> bool {
|
||||
debug!("read_bool");
|
||||
match self.stack.pop() {
|
||||
Boolean(b) => b,
|
||||
value => fail!(fmt!("not a boolean: %?", value))
|
||||
}
|
||||
}
|
||||
|
||||
fn read_f64(&self) -> f64 { self.read_float() as f64 }
|
||||
fn read_f32(&self) -> f32 { self.read_float() as f32 }
|
||||
fn read_float(&self) -> float {
|
||||
debug!("read_float");
|
||||
match self.stack.pop() {
|
||||
Number(f) => f,
|
||||
value => fail!(fmt!("not a number: %?", value))
|
||||
}
|
||||
}
|
||||
|
||||
fn read_char(&self) -> char {
|
||||
let mut v = ~[];
|
||||
for str::each_char(self.read_str()) |c| { v.push(c) }
|
||||
if v.len() != 1 { fail!(~"string must have one character") }
|
||||
v[0]
|
||||
}
|
||||
|
||||
fn read_str(&self) -> ~str {
|
||||
debug!("read_str");
|
||||
match self.stack.pop() {
|
||||
String(s) => s,
|
||||
json => fail!(fmt!("not a string: %?", json))
|
||||
}
|
||||
}
|
||||
|
||||
fn read_enum<T>(&self, name: &str, f: &fn() -> T) -> T {
|
||||
debug!("read_enum(%s)", name);
|
||||
f()
|
||||
}
|
||||
|
||||
fn read_enum_variant<T>(&self,
|
||||
names: &[&str],
|
||||
f: &fn(uint) -> T)
|
||||
-> T {
|
||||
debug!("read_enum_variant(names=%?)", names);
|
||||
let name = match self.stack.pop() {
|
||||
String(s) => s,
|
||||
List(list) => {
|
||||
do vec::consume_reverse(list) |_i, v| {
|
||||
self.stack.push(v);
|
||||
}
|
||||
match self.stack.pop() {
|
||||
String(s) => s,
|
||||
value => fail!(fmt!("invalid variant name: %?", value)),
|
||||
}
|
||||
}
|
||||
ref json => fail!(fmt!("invalid variant: %?", *json)),
|
||||
};
|
||||
let idx = match vec::position(names, |n| str::eq_slice(*n, name)) {
|
||||
Some(idx) => idx,
|
||||
None => fail!(fmt!("Unknown variant name: %?", name)),
|
||||
};
|
||||
f(idx)
|
||||
}
|
||||
|
||||
fn read_enum_variant_arg<T>(&self, idx: uint, f: &fn() -> T) -> T {
|
||||
debug!("read_enum_variant_arg(idx=%u)", idx);
|
||||
f()
|
||||
}
|
||||
|
||||
fn read_enum_struct_variant<T>(&self,
|
||||
names: &[&str],
|
||||
f: &fn(uint) -> T)
|
||||
-> T {
|
||||
debug!("read_enum_struct_variant(names=%?)", names);
|
||||
self.read_enum_variant(names, f)
|
||||
}
|
||||
|
||||
|
||||
fn read_enum_struct_variant_field<T>(&self,
|
||||
name: &str,
|
||||
idx: uint,
|
||||
f: &fn() -> T)
|
||||
-> T {
|
||||
debug!("read_enum_struct_variant_field(name=%?, idx=%u)", name, idx);
|
||||
self.read_enum_variant_arg(idx, f)
|
||||
}
|
||||
|
||||
fn read_struct<T>(&self, name: &str, len: uint, f: &fn() -> T) -> T {
|
||||
debug!("read_struct(name=%s, len=%u)", name, len);
|
||||
let value = f();
|
||||
self.stack.pop();
|
||||
value
|
||||
}
|
||||
|
||||
#[cfg(stage0)]
|
||||
fn read_field<T>(&self, name: &str, idx: uint, f: &fn() -> T) -> T {
|
||||
debug!("read_field(name=%?, idx=%u)", name, idx);
|
||||
match self.stack.pop() {
|
||||
Object(obj) => {
|
||||
let mut obj = obj;
|
||||
let value = match obj.pop(&name.to_owned()) {
|
||||
None => fail!(fmt!("no such field: %s", name)),
|
||||
Some(json) => {
|
||||
self.stack.push(json);
|
||||
f()
|
||||
}
|
||||
};
|
||||
self.stack.push(Object(obj));
|
||||
value
|
||||
}
|
||||
value => fail!(fmt!("not an object: %?", value))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
#[cfg(stage3)]
|
||||
fn read_struct_field<T>(&self,
|
||||
name: &str,
|
||||
idx: uint,
|
||||
f: &fn() -> T)
|
||||
-> T {
|
||||
debug!("read_struct_field(name=%?, idx=%u)", name, idx);
|
||||
match self.stack.pop() {
|
||||
Object(obj) => {
|
||||
let mut obj = obj;
|
||||
let value = match obj.pop(&name.to_owned()) {
|
||||
None => fail!(fmt!("no such field: %s", name)),
|
||||
Some(json) => {
|
||||
self.stack.push(json);
|
||||
f()
|
||||
}
|
||||
};
|
||||
self.stack.push(Object(obj));
|
||||
value
|
||||
}
|
||||
value => fail!(fmt!("not an object: %?", value))
|
||||
}
|
||||
}
|
||||
|
||||
fn read_tuple<T>(&self, f: &fn(uint) -> T) -> T {
|
||||
debug!("read_tuple()");
|
||||
self.read_seq(f)
|
||||
}
|
||||
|
||||
fn read_tuple_arg<T>(&self, idx: uint, f: &fn() -> T) -> T {
|
||||
debug!("read_tuple_arg(idx=%u)", idx);
|
||||
self.read_seq_elt(idx, f)
|
||||
}
|
||||
|
||||
fn read_tuple_struct<T>(&self, name: &str, f: &fn(uint) -> T) -> T {
|
||||
debug!("read_tuple_struct(name=%?)", name);
|
||||
self.read_tuple(f)
|
||||
}
|
||||
|
||||
fn read_tuple_struct_arg<T>(&self, idx: uint, f: &fn() -> T) -> T {
|
||||
debug!("read_tuple_struct_arg(idx=%u)", idx);
|
||||
self.read_tuple_arg(idx, f)
|
||||
}
|
||||
|
||||
fn read_option<T>(&self, f: &fn(bool) -> T) -> T {
|
||||
match self.stack.pop() {
|
||||
Null => f(false),
|
||||
value => { self.stack.push(value); f(true) }
|
||||
}
|
||||
}
|
||||
|
||||
fn read_seq<T>(&self, f: &fn(uint) -> T) -> T {
|
||||
debug!("read_seq()");
|
||||
let len = match self.stack.pop() {
|
||||
List(list) => {
|
||||
let len = list.len();
|
||||
do vec::consume_reverse(list) |_i, v| {
|
||||
self.stack.push(v);
|
||||
}
|
||||
len
|
||||
}
|
||||
_ => fail!(~"not a list"),
|
||||
};
|
||||
f(len)
|
||||
}
|
||||
|
||||
fn read_seq_elt<T>(&self, idx: uint, f: &fn() -> T) -> T {
|
||||
debug!("read_seq_elt(idx=%u)", idx);
|
||||
f()
|
||||
}
|
||||
|
||||
fn read_map<T>(&self, f: &fn(uint) -> T) -> T {
|
||||
debug!("read_map()");
|
||||
let len = match self.stack.pop() {
|
||||
Object(obj) => {
|
||||
let mut obj = obj;
|
||||
let len = obj.len();
|
||||
do obj.consume |key, value| {
|
||||
self.stack.push(value);
|
||||
self.stack.push(String(key));
|
||||
}
|
||||
len
|
||||
}
|
||||
json => fail!(fmt!("not an object: %?", json)),
|
||||
};
|
||||
f(len)
|
||||
}
|
||||
|
||||
fn read_map_elt_key<T>(&self, idx: uint, f: &fn() -> T) -> T {
|
||||
debug!("read_map_elt_key(idx=%u)", idx);
|
||||
f()
|
||||
}
|
||||
|
||||
fn read_map_elt_val<T>(&self, idx: uint, f: &fn() -> T) -> T {
|
||||
debug!("read_map_elt_val(idx=%u)", idx);
|
||||
f()
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(stage0))]
|
||||
impl serialize::Decoder for Decoder {
|
||||
fn read_nil(&mut self) -> () {
|
||||
debug!("read_nil");
|
||||
|
|
@ -1577,29 +969,6 @@ impl serialize::Decoder for Decoder {
|
|||
value
|
||||
}
|
||||
|
||||
#[cfg(stage0)]
|
||||
fn read_field<T>(&mut self, name: &str, idx: uint, f: &fn() -> T) -> T {
|
||||
debug!("read_field(name=%?, idx=%u)", name, idx);
|
||||
match self.stack.pop() {
|
||||
Object(obj) => {
|
||||
let mut obj = obj;
|
||||
let value = match obj.pop(&name.to_owned()) {
|
||||
None => fail!(fmt!("no such field: %s", name)),
|
||||
Some(json) => {
|
||||
self.stack.push(json);
|
||||
f()
|
||||
}
|
||||
};
|
||||
self.stack.push(Object(obj));
|
||||
value
|
||||
}
|
||||
value => fail!(fmt!("not an object: %?", value))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(stage1)]
|
||||
#[cfg(stage2)]
|
||||
#[cfg(stage3)]
|
||||
fn read_struct_field<T>(&mut self,
|
||||
name: &str,
|
||||
idx: uint,
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue