escape_str(self.writer, v)
}
- fn emit_enum(&mut self,
- _name: &str,
- f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_enum<F>(&mut self, _name: &str, f: F) -> EncodeResult where
+ F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
+ {
f(self)
}
- fn emit_enum_variant(&mut self,
- name: &str,
- _id: uint,
- cnt: uint,
- f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_enum_variant<F>(&mut self,
+ name: &str,
+ _id: uint,
+ cnt: uint,
+ f: F) -> EncodeResult where
+ F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
+ {
// enums are encoded as strings or objects
// Bunny => "Bunny"
// Kangaroo(34,"William") => {"variant": "Kangaroo", "fields": [34,"William"]}
}
}
- fn emit_enum_variant_arg(&mut self,
- idx: uint,
- f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_enum_variant_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
+ F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
+ {
if idx != 0 {
try!(write!(self.writer, ","));
}
f(self)
}
- fn emit_enum_struct_variant(&mut self,
- name: &str,
- id: uint,
- cnt: uint,
- f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_enum_struct_variant<F>(&mut self,
+ name: &str,
+ id: uint,
+ cnt: uint,
+ f: F) -> EncodeResult where
+ F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
+ {
self.emit_enum_variant(name, id, cnt, f)
}
- fn emit_enum_struct_variant_field(&mut self,
- _: &str,
- idx: uint,
- f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_enum_struct_variant_field<F>(&mut self,
+ _: &str,
+ idx: uint,
+ f: F) -> EncodeResult where
+ F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
+ {
self.emit_enum_variant_arg(idx, f)
}
- fn emit_struct(&mut self,
- _: &str,
- _: uint,
- f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_struct<F>(&mut self, _: &str, _: uint, f: F) -> EncodeResult where
+ F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
+ {
try!(write!(self.writer, "{{"));
try!(f(self));
write!(self.writer, "}}")
}
- fn emit_struct_field(&mut self,
- name: &str,
- idx: uint,
- f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_struct_field<F>(&mut self, name: &str, idx: uint, f: F) -> EncodeResult where
+ F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
+ {
if idx != 0 { try!(write!(self.writer, ",")); }
try!(escape_str(self.writer, name));
try!(write!(self.writer, ":"));
f(self)
}
- fn emit_tuple(&mut self, len: uint, f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_tuple<F>(&mut self, len: uint, f: F) -> EncodeResult where
+ F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
+ {
self.emit_seq(len, f)
}
- fn emit_tuple_arg(&mut self,
- idx: uint,
- f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_tuple_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
+ F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
+ {
self.emit_seq_elt(idx, f)
}
- fn emit_tuple_struct(&mut self,
- _name: &str,
- len: uint,
- f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_tuple_struct<F>(&mut self, _name: &str, len: uint, f: F) -> EncodeResult where
+ F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
+ {
self.emit_seq(len, f)
}
- fn emit_tuple_struct_arg(&mut self,
- idx: uint,
- f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_tuple_struct_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
+ F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
+ {
self.emit_seq_elt(idx, f)
}
- fn emit_option(&mut self, f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_option<F>(&mut self, f: F) -> EncodeResult where
+ F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
+ {
f(self)
}
fn emit_option_none(&mut self) -> EncodeResult { self.emit_nil() }
- fn emit_option_some(&mut self, f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_option_some<F>(&mut self, f: F) -> EncodeResult where
+ F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
+ {
f(self)
}
- fn emit_seq(&mut self, _len: uint, f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_seq<F>(&mut self, _len: uint, f: F) -> EncodeResult where
+ F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
+ {
try!(write!(self.writer, "["));
try!(f(self));
write!(self.writer, "]")
}
- fn emit_seq_elt(&mut self, idx: uint, f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_seq_elt<F>(&mut self, idx: uint, f: F) -> EncodeResult where
+ F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
+ {
if idx != 0 {
try!(write!(self.writer, ","));
}
f(self)
}
- fn emit_map(&mut self, _len: uint, f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_map<F>(&mut self, _len: uint, f: F) -> EncodeResult where
+ F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
+ {
try!(write!(self.writer, "{{"));
try!(f(self));
write!(self.writer, "}}")
}
- fn emit_map_elt_key(&mut self,
- idx: uint,
- f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_map_elt_key<F>(&mut self, idx: uint, mut f: F) -> EncodeResult where
+ F: FnMut(&mut Encoder<'a>) -> EncodeResult,
+ {
if idx != 0 { try!(write!(self.writer, ",")) }
// ref #12967, make sure to wrap a key in double quotes,
// in the event that its of a type that omits them (eg numbers)
Ok(())
}
- fn emit_map_elt_val(&mut self,
- _idx: uint,
- f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_map_elt_val<F>(&mut self, _idx: uint, f: F) -> EncodeResult where
+ F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
+ {
try!(write!(self.writer, ":"));
f(self)
}
escape_str(self.writer, v)
}
- fn emit_enum(&mut self,
- _name: &str,
- f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_enum<F>(&mut self, _name: &str, f: F) -> EncodeResult where
+ F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
+ {
f(self)
}
- fn emit_enum_variant(&mut self,
- name: &str,
- _id: uint,
- cnt: uint,
- f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_enum_variant<F>(&mut self,
+ name: &str,
+ _id: uint,
+ cnt: uint,
+ f: F)
+ -> EncodeResult where
+ F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
+ {
if cnt == 0 {
escape_str(self.writer, name)
} else {
}
}
- fn emit_enum_variant_arg(&mut self,
- idx: uint,
- f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_enum_variant_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
+ F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
+ {
if idx != 0 {
try!(write!(self.writer, ",\n"));
}
f(self)
}
- fn emit_enum_struct_variant(&mut self,
- name: &str,
- id: uint,
- cnt: uint,
- f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_enum_struct_variant<F>(&mut self,
+ name: &str,
+ id: uint,
+ cnt: uint,
+ f: F) -> EncodeResult where
+ F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
+ {
self.emit_enum_variant(name, id, cnt, f)
}
- fn emit_enum_struct_variant_field(&mut self,
- _: &str,
- idx: uint,
- f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_enum_struct_variant_field<F>(&mut self,
+ _: &str,
+ idx: uint,
+ f: F) -> EncodeResult where
+ F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
+ {
self.emit_enum_variant_arg(idx, f)
}
- fn emit_struct(&mut self,
- _: &str,
- len: uint,
- f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_struct<F>(&mut self, _: &str, len: uint, f: F) -> EncodeResult where
+ F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
+ {
if len == 0 {
write!(self.writer, "{{}}")
} else {
}
}
- fn emit_struct_field(&mut self,
- name: &str,
- idx: uint,
- f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_struct_field<F>(&mut self, name: &str, idx: uint, f: F) -> EncodeResult where
+ F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
+ {
if idx == 0 {
try!(write!(self.writer, "\n"));
} else {
f(self)
}
- fn emit_tuple(&mut self,
- len: uint,
- f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_tuple<F>(&mut self, len: uint, f: F) -> EncodeResult where
+ F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
+ {
self.emit_seq(len, f)
}
- fn emit_tuple_arg(&mut self,
- idx: uint,
- f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_tuple_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
+ F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
+ {
self.emit_seq_elt(idx, f)
}
- fn emit_tuple_struct(&mut self,
- _: &str,
- len: uint,
- f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_tuple_struct<F>(&mut self, _: &str, len: uint, f: F) -> EncodeResult where
+ F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
+ {
self.emit_seq(len, f)
}
- fn emit_tuple_struct_arg(&mut self,
- idx: uint,
- f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_tuple_struct_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
+ F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
+ {
self.emit_seq_elt(idx, f)
}
- fn emit_option(&mut self, f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_option<F>(&mut self, f: F) -> EncodeResult where
+ F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
+ {
f(self)
}
fn emit_option_none(&mut self) -> EncodeResult { self.emit_nil() }
- fn emit_option_some(&mut self, f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_option_some<F>(&mut self, f: F) -> EncodeResult where
+ F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
+ {
f(self)
}
- fn emit_seq(&mut self,
- len: uint,
- f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_seq<F>(&mut self, len: uint, f: F) -> EncodeResult where
+ F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
+ {
if len == 0 {
write!(self.writer, "[]")
} else {
}
}
- fn emit_seq_elt(&mut self,
- idx: uint,
- f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_seq_elt<F>(&mut self, idx: uint, f: F) -> EncodeResult where
+ F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
+ {
if idx == 0 {
try!(write!(self.writer, "\n"));
} else {
f(self)
}
- fn emit_map(&mut self,
- len: uint,
- f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_map<F>(&mut self, len: uint, f: F) -> EncodeResult where
+ F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
+ {
if len == 0 {
write!(self.writer, "{{}}")
} else {
}
}
- fn emit_map_elt_key(&mut self,
- idx: uint,
- f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_map_elt_key<F>(&mut self, idx: uint, mut f: F) -> EncodeResult where
+ F: FnMut(&mut PrettyEncoder<'a>) -> EncodeResult,
+ {
if idx == 0 {
try!(write!(self.writer, "\n"));
} else {
Ok(())
}
- fn emit_map_elt_val(&mut self,
- _idx: uint,
- f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
+ fn emit_map_elt_val<F>(&mut self, _idx: uint, f: F) -> EncodeResult where
+ F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
+ {
try!(write!(self.writer, ": "));
f(self)
}
expect!(self.pop(), String)
}
- fn read_enum<T>(&mut self,
- name: &str,
- f: |&mut Decoder| -> DecodeResult<T>) -> DecodeResult<T> {
+ fn read_enum<T, F>(&mut self, name: &str, f: F) -> DecodeResult<T> where
+ F: FnOnce(&mut Decoder) -> DecodeResult<T>,
+ {
debug!("read_enum({})", name);
f(self)
}
- fn read_enum_variant<T>(&mut self,
- names: &[&str],
- f: |&mut Decoder, uint| -> DecodeResult<T>)
- -> DecodeResult<T> {
+ fn read_enum_variant<T, F>(&mut self, names: &[&str], f: F) -> DecodeResult<T> where
+ F: FnOnce(&mut Decoder, uint) -> DecodeResult<T>,
+ {
debug!("read_enum_variant(names={})", names);
let name = match self.pop() {
Json::String(s) => s,
f(self, idx)
}
- fn read_enum_variant_arg<T>(&mut self, idx: uint, f: |&mut Decoder| -> DecodeResult<T>)
- -> DecodeResult<T> {
+ fn read_enum_variant_arg<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
+ F: FnOnce(&mut Decoder) -> DecodeResult<T>,
+ {
debug!("read_enum_variant_arg(idx={})", idx);
f(self)
}
- fn read_enum_struct_variant<T>(&mut self,
- names: &[&str],
- f: |&mut Decoder, uint| -> DecodeResult<T>)
- -> DecodeResult<T> {
+ fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> DecodeResult<T> where
+ F: FnOnce(&mut Decoder, uint) -> DecodeResult<T>,
+ {
debug!("read_enum_struct_variant(names={})", names);
self.read_enum_variant(names, f)
}
- fn read_enum_struct_variant_field<T>(&mut self,
+ fn read_enum_struct_variant_field<T, F>(&mut self,
name: &str,
idx: uint,
- f: |&mut Decoder| -> DecodeResult<T>)
- -> DecodeResult<T> {
+ f: F)
+ -> DecodeResult<T> where
+ F: FnOnce(&mut Decoder) -> DecodeResult<T>,
+ {
debug!("read_enum_struct_variant_field(name={}, idx={})", name, idx);
self.read_enum_variant_arg(idx, f)
}
- fn read_struct<T>(&mut self,
- name: &str,
- len: uint,
- f: |&mut Decoder| -> DecodeResult<T>)
- -> DecodeResult<T> {
+ fn read_struct<T, F>(&mut self, name: &str, len: uint, f: F) -> DecodeResult<T> where
+ F: FnOnce(&mut Decoder) -> DecodeResult<T>,
+ {
debug!("read_struct(name={}, len={})", name, len);
let value = try!(f(self));
self.pop();
Ok(value)
}
- fn read_struct_field<T>(&mut self,
- name: &str,
- idx: uint,
- f: |&mut Decoder| -> DecodeResult<T>)
- -> DecodeResult<T> {
+ fn read_struct_field<T, F>(&mut self,
+ name: &str,
+ idx: uint,
+ f: F)
+ -> DecodeResult<T> where
+ F: FnOnce(&mut Decoder) -> DecodeResult<T>,
+ {
debug!("read_struct_field(name={}, idx={})", name, idx);
let mut obj = try!(expect!(self.pop(), Object));
Ok(value)
}
- fn read_tuple<T>(&mut self,
- tuple_len: uint,
- f: |&mut Decoder| -> DecodeResult<T>)
- -> DecodeResult<T> {
+ fn read_tuple<T, F>(&mut self, tuple_len: uint, f: F) -> DecodeResult<T> where
+ F: FnOnce(&mut Decoder) -> DecodeResult<T>,
+ {
debug!("read_tuple()");
- self.read_seq(|d, len| {
+ self.read_seq(move |d, len| {
if len == tuple_len {
f(d)
} else {
})
}
- fn read_tuple_arg<T>(&mut self,
- idx: uint,
- f: |&mut Decoder| -> DecodeResult<T>) -> DecodeResult<T> {
+ fn read_tuple_arg<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
+ F: FnOnce(&mut Decoder) -> DecodeResult<T>,
+ {
debug!("read_tuple_arg(idx={})", idx);
self.read_seq_elt(idx, f)
}
- fn read_tuple_struct<T>(&mut self,
- name: &str,
- len: uint,
- f: |&mut Decoder| -> DecodeResult<T>)
- -> DecodeResult<T> {
+ fn read_tuple_struct<T, F>(&mut self,
+ name: &str,
+ len: uint,
+ f: F)
+ -> DecodeResult<T> where
+ F: FnOnce(&mut Decoder) -> DecodeResult<T>,
+ {
debug!("read_tuple_struct(name={})", name);
self.read_tuple(len, f)
}
- fn read_tuple_struct_arg<T>(&mut self,
- idx: uint,
- f: |&mut Decoder| -> DecodeResult<T>)
- -> DecodeResult<T> {
+ fn read_tuple_struct_arg<T, F>(&mut self,
+ idx: uint,
+ f: F)
+ -> DecodeResult<T> where
+ F: FnOnce(&mut Decoder) -> DecodeResult<T>,
+ {
debug!("read_tuple_struct_arg(idx={})", idx);
self.read_tuple_arg(idx, f)
}
- fn read_option<T>(&mut self, f: |&mut Decoder, bool| -> DecodeResult<T>) -> DecodeResult<T> {
+ fn read_option<T, F>(&mut self, f: F) -> DecodeResult<T> where
+ F: FnOnce(&mut Decoder, bool) -> DecodeResult<T>,
+ {
debug!("read_option()");
match self.pop() {
Json::Null => f(self, false),
}
}
- fn read_seq<T>(&mut self, f: |&mut Decoder, uint| -> DecodeResult<T>) -> DecodeResult<T> {
+ fn read_seq<T, F>(&mut self, f: F) -> DecodeResult<T> where
+ F: FnOnce(&mut Decoder, uint) -> DecodeResult<T>,
+ {
debug!("read_seq()");
let array = try!(expect!(self.pop(), Array));
let len = array.len();
f(self, len)
}
- fn read_seq_elt<T>(&mut self,
- idx: uint,
- f: |&mut Decoder| -> DecodeResult<T>) -> DecodeResult<T> {
+ fn read_seq_elt<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
+ F: FnOnce(&mut Decoder) -> DecodeResult<T>,
+ {
debug!("read_seq_elt(idx={})", idx);
f(self)
}
- fn read_map<T>(&mut self, f: |&mut Decoder, uint| -> DecodeResult<T>) -> DecodeResult<T> {
+ fn read_map<T, F>(&mut self, f: F) -> DecodeResult<T> where
+ F: FnOnce(&mut Decoder, uint) -> DecodeResult<T>,
+ {
debug!("read_map()");
let obj = try!(expect!(self.pop(), Object));
let len = obj.len();
f(self, len)
}
- fn read_map_elt_key<T>(&mut self, idx: uint, f: |&mut Decoder| -> DecodeResult<T>)
- -> DecodeResult<T> {
+ fn read_map_elt_key<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
+ F: FnOnce(&mut Decoder) -> DecodeResult<T>,
+ {
debug!("read_map_elt_key(idx={})", idx);
f(self)
}
- fn read_map_elt_val<T>(&mut self, idx: uint, f: |&mut Decoder| -> DecodeResult<T>)
- -> DecodeResult<T> {
+ fn read_map_elt_val<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
+ F: FnOnce(&mut Decoder) -> DecodeResult<T>,
+ {
debug!("read_map_elt_val(idx={})", idx);
f(self)
}
fn emit_str(&mut self, v: &str) -> Result<(), E>;
// Compound types:
- fn emit_enum(&mut self, name: &str, f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
-
- fn emit_enum_variant(&mut self,
- v_name: &str,
- v_id: uint,
- len: uint,
- f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
- fn emit_enum_variant_arg(&mut self,
- a_idx: uint,
- f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
-
- fn emit_enum_struct_variant(&mut self,
- v_name: &str,
- v_id: uint,
- len: uint,
- f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
- fn emit_enum_struct_variant_field(&mut self,
- f_name: &str,
- f_idx: uint,
- f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
-
- fn emit_struct(&mut self,
- name: &str,
- len: uint,
- f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
- fn emit_struct_field(&mut self,
- f_name: &str,
- f_idx: uint,
- f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
-
- fn emit_tuple(&mut self, len: uint, f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
- fn emit_tuple_arg(&mut self, idx: uint, f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
-
- fn emit_tuple_struct(&mut self,
- name: &str,
- len: uint,
- f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
- fn emit_tuple_struct_arg(&mut self,
- f_idx: uint,
- f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
+ fn emit_enum<F>(&mut self, name: &str, f: F) -> Result<(), E> where
+ F: FnOnce(&mut Self) -> Result<(), E>;
+
+ fn emit_enum_variant<F>(&mut self, v_name: &str,
+ v_id: uint,
+ len: uint,
+ f: F) -> Result<(), E> where
+ F: FnOnce(&mut Self) -> Result<(), E>;
+ fn emit_enum_variant_arg<F>(&mut self, a_idx: uint, f: F) -> Result<(), E> where
+ F: FnOnce(&mut Self) -> Result<(), E>;
+
+ fn emit_enum_struct_variant<F>(&mut self, v_name: &str,
+ v_id: uint,
+ len: uint,
+ f: F) -> Result<(), E> where
+ F: FnOnce(&mut Self) -> Result<(), E>;
+ fn emit_enum_struct_variant_field<F>(&mut self,
+ f_name: &str,
+ f_idx: uint,
+ f: F) -> Result<(), E> where
+ F: FnOnce(&mut Self) -> Result<(), E>;
+
+ fn emit_struct<F>(&mut self, name: &str, len: uint, f: F) -> Result<(), E> where
+ F: FnOnce(&mut Self) -> Result<(), E>;
+ fn emit_struct_field<F>(&mut self, f_name: &str, f_idx: uint, f: F) -> Result<(), E> where
+ F: FnOnce(&mut Self) -> Result<(), E>;
+
+ fn emit_tuple<F>(&mut self, len: uint, f: F) -> Result<(), E> where
+ F: FnOnce(&mut Self) -> Result<(), E>;
+ fn emit_tuple_arg<F>(&mut self, idx: uint, f: F) -> Result<(), E> where
+ F: FnOnce(&mut Self) -> Result<(), E>;
+
+ fn emit_tuple_struct<F>(&mut self, name: &str, len: uint, f: F) -> Result<(), E> where
+ F: FnOnce(&mut Self) -> Result<(), E>;
+ fn emit_tuple_struct_arg<F>(&mut self, f_idx: uint, f: F) -> Result<(), E> where
+ F: FnOnce(&mut Self) -> Result<(), E>;
// Specialized types:
- fn emit_option(&mut self, f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
+ fn emit_option<F>(&mut self, f: F) -> Result<(), E> where
+ F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_option_none(&mut self) -> Result<(), E>;
- fn emit_option_some(&mut self, f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
+ fn emit_option_some<F>(&mut self, f: F) -> Result<(), E> where
+ F: FnOnce(&mut Self) -> Result<(), E>;
- fn emit_seq(&mut self, len: uint, f: |this: &mut Self| -> Result<(), E>) -> Result<(), E>;
- fn emit_seq_elt(&mut self, idx: uint, f: |this: &mut Self| -> Result<(), E>) -> Result<(), E>;
+ fn emit_seq<F>(&mut self, len: uint, f: F) -> Result<(), E> where
+ F: FnOnce(&mut Self) -> Result<(), E>;
+ fn emit_seq_elt<F>(&mut self, idx: uint, f: F) -> Result<(), E> where
+ F: FnOnce(&mut Self) -> Result<(), E>;
- fn emit_map(&mut self, len: uint, f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
- fn emit_map_elt_key(&mut self, idx: uint, f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
- fn emit_map_elt_val(&mut self, idx: uint, f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
+ fn emit_map<F>(&mut self, len: uint, f: F) -> Result<(), E> where
+ F: FnOnce(&mut Self) -> Result<(), E>;
+ fn emit_map_elt_key<F>(&mut self, idx: uint, f: F) -> Result<(), E> where
+ F: FnMut(&mut Self) -> Result<(), E>;
+ fn emit_map_elt_val<F>(&mut self, idx: uint, f: F) -> Result<(), E> where
+ F: FnOnce(&mut Self) -> Result<(), E>;
}
pub trait Decoder<E> {
fn read_str(&mut self) -> Result<String, E>;
// Compound types:
- fn read_enum<T>(&mut self, name: &str, f: |&mut Self| -> Result<T, E>) -> Result<T, E>;
-
- fn read_enum_variant<T>(&mut self,
- names: &[&str],
- f: |&mut Self, uint| -> Result<T, E>)
- -> Result<T, E>;
- fn read_enum_variant_arg<T>(&mut self,
- a_idx: uint,
- f: |&mut Self| -> Result<T, E>)
- -> Result<T, E>;
-
- fn read_enum_struct_variant<T>(&mut self,
- names: &[&str],
- f: |&mut Self, uint| -> Result<T, E>)
- -> Result<T, E>;
- fn read_enum_struct_variant_field<T>(&mut self,
- &f_name: &str,
- f_idx: uint,
- f: |&mut Self| -> Result<T, E>)
- -> Result<T, E>;
-
- fn read_struct<T>(&mut self, s_name: &str, len: uint, f: |&mut Self| -> Result<T, E>)
- -> Result<T, E>;
- fn read_struct_field<T>(&mut self,
- f_name: &str,
- f_idx: uint,
- f: |&mut Self| -> Result<T, E>)
- -> Result<T, E>;
-
- fn read_tuple<T>(&mut self, len: uint, f: |&mut Self| -> Result<T, E>) -> Result<T, E>;
- fn read_tuple_arg<T>(&mut self, a_idx: uint, f: |&mut Self| -> Result<T, E>) -> Result<T, E>;
-
- fn read_tuple_struct<T>(&mut self,
- s_name: &str,
- len: uint,
- f: |&mut Self| -> Result<T, E>)
- -> Result<T, E>;
- fn read_tuple_struct_arg<T>(&mut self,
- a_idx: uint,
- f: |&mut Self| -> Result<T, E>)
- -> Result<T, E>;
+ fn read_enum<T, F>(&mut self, name: &str, f: F) -> Result<T, E> where
+ F: FnOnce(&mut Self) -> Result<T, E>;
+
+ fn read_enum_variant<T, F>(&mut self, names: &[&str], f: F) -> Result<T, E> where
+ F: FnOnce(&mut Self, uint) -> Result<T, E>;
+ fn read_enum_variant_arg<T, F>(&mut self, a_idx: uint, f: F) -> Result<T, E> where
+ F: FnOnce(&mut Self) -> Result<T, E>;
+
+ fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> Result<T, E> where
+ F: FnOnce(&mut Self, uint) -> Result<T, E>;
+ fn read_enum_struct_variant_field<T, F>(&mut self,
+ &f_name: &str,
+ f_idx: uint,
+ f: F)
+ -> Result<T, E> where
+ F: FnOnce(&mut Self) -> Result<T, E>;
+
+ fn read_struct<T, F>(&mut self, s_name: &str, len: uint, f: F) -> Result<T, E> where
+ F: FnOnce(&mut Self) -> Result<T, E>;
+ fn read_struct_field<T, F>(&mut self,
+ f_name: &str,
+ f_idx: uint,
+ f: F)
+ -> Result<T, E> where
+ F: FnOnce(&mut Self) -> Result<T, E>;
+
+ fn read_tuple<T, F>(&mut self, len: uint, f: F) -> Result<T, E> where
+ F: FnOnce(&mut Self) -> Result<T, E>;
+ fn read_tuple_arg<T, F>(&mut self, a_idx: uint, f: F) -> Result<T, E> where
+ F: FnOnce(&mut Self) -> Result<T, E>;
+
+ fn read_tuple_struct<T, F>(&mut self, s_name: &str, len: uint, f: F) -> Result<T, E> where
+ F: FnOnce(&mut Self) -> Result<T, E>;
+ fn read_tuple_struct_arg<T, F>(&mut self, a_idx: uint, f: F) -> Result<T, E> where
+ F: FnOnce(&mut Self) -> Result<T, E>;
// Specialized types:
- fn read_option<T>(&mut self, f: |&mut Self, bool| -> Result<T, E>) -> Result<T, E>;
+ fn read_option<T, F>(&mut self, f: F) -> Result<T, E> where
+ F: FnOnce(&mut Self, bool) -> Result<T, E>;
- fn read_seq<T>(&mut self, f: |&mut Self, uint| -> Result<T, E>) -> Result<T, E>;
- fn read_seq_elt<T>(&mut self, idx: uint, f: |&mut Self| -> Result<T, E>) -> Result<T, E>;
+ fn read_seq<T, F>(&mut self, f: F) -> Result<T, E> where
+ F: FnOnce(&mut Self, uint) -> Result<T, E>;
+ fn read_seq_elt<T, F>(&mut self, idx: uint, f: F) -> Result<T, E> where
+ F: FnOnce(&mut Self) -> Result<T, E>;
- fn read_map<T>(&mut self, f: |&mut Self, uint| -> Result<T, E>) -> Result<T, E>;
- fn read_map_elt_key<T>(&mut self, idx: uint, f: |&mut Self| -> Result<T, E>) -> Result<T, E>;
- fn read_map_elt_val<T>(&mut self, idx: uint, f: |&mut Self| -> Result<T, E>) -> Result<T, E>;
+ fn read_map<T, F>(&mut self, f: F) -> Result<T, E> where
+ F: FnOnce(&mut Self, uint) -> Result<T, E>;
+ fn read_map_elt_key<T, F>(&mut self, idx: uint, f: F) -> Result<T, E> where
+ F: FnOnce(&mut Self) -> Result<T, E>;
+ fn read_map_elt_val<T, F>(&mut self, idx: uint, f: F) -> Result<T, E> where
+ F: FnOnce(&mut Self) -> Result<T, E>;
// Failure
fn error(&mut self, err: &str) -> E;
// Helper routines
pub trait EncoderHelpers<E> {
- fn emit_from_vec<T>(&mut self,
- v: &[T],
- f: |&mut Self, v: &T| -> Result<(), E>) -> Result<(), E>;
+ fn emit_from_vec<T, F>(&mut self, v: &[T], f: F) -> Result<(), E> where
+ F: FnMut(&mut Self, &T) -> Result<(), E>;
}
impl<E, S:Encoder<E>> EncoderHelpers<E> for S {
- fn emit_from_vec<T>(&mut self, v: &[T], f: |&mut S, &T| -> Result<(), E>) -> Result<(), E> {
+ fn emit_from_vec<T, F>(&mut self, v: &[T], mut f: F) -> Result<(), E> where
+ F: FnMut(&mut S, &T) -> Result<(), E>,
+ {
self.emit_seq(v.len(), |this| {
for (i, e) in v.iter().enumerate() {
try!(this.emit_seq_elt(i, |this| {
}
pub trait DecoderHelpers<E> {
- fn read_to_vec<T>(&mut self, f: |&mut Self| -> Result<T, E>) -> Result<Vec<T>, E>;
+ fn read_to_vec<T, F>(&mut self, f: F) -> Result<Vec<T>, E> where
+ F: FnMut(&mut Self) -> Result<T, E>;
}
impl<E, D:Decoder<E>> DecoderHelpers<E> for D {
- fn read_to_vec<T>(&mut self, f: |&mut D| -> Result<T, E>) -> Result<Vec<T>, E> {
+ fn read_to_vec<T, F>(&mut self, mut f: F) -> Result<Vec<T>, E> where F:
+ FnMut(&mut D) -> Result<T, E>,
+ {
self.read_seq(|this, len| {
let mut v = Vec::with_capacity(len);
for i in range(0, len) {