squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

libserialize: use unboxed closures

Browse source
This commit is contained in:
Jorge Aparicio 2014-12-06 14:30:22 -05:00
parent 533a47bd9b
commit a8aff7e95c
3 changed files with 294 additions and 251 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

357
src/libserialize/json.rs
View file

@ -458,17 +458,19 @@ impl<'a> ::Encoder<io::IoError> for Encoder<'a> {
escape_str(self.writer, v) escape_str(self.writer, v)
} }
fn emit_enum(&mut self, fn emit_enum<F>(&mut self, _name: &str, f: F) -> EncodeResult where
_name: &str, F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult { {
f(self) f(self)
} }
fn emit_enum_variant(&mut self, fn emit_enum_variant<F>(&mut self,
name: &str, name: &str,
_id: uint, _id: uint,
cnt: uint, cnt: uint,
f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult { f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
// 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"]}
@ -483,100 +485,113 @@ impl<'a> ::Encoder<io::IoError> for Encoder<'a> {
} }
} }
fn emit_enum_variant_arg(&mut self, fn emit_enum_variant_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
idx: uint, F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult { {
if idx != 0 { if idx != 0 {
try!(write!(self.writer, ",")); try!(write!(self.writer, ","));
} }
f(self) f(self)
} }
fn emit_enum_struct_variant(&mut self, fn emit_enum_struct_variant<F>(&mut self,
name: &str, name: &str,
id: uint, id: uint,
cnt: uint, cnt: uint,
f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult { f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
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<F>(&mut self,
_: &str, _: &str,
idx: uint, idx: uint,
f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult { f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
self.emit_enum_variant_arg(idx, f) self.emit_enum_variant_arg(idx, f)
} }
fn emit_struct(&mut self, fn emit_struct<F>(&mut self, _: &str, _: uint, f: F) -> EncodeResult where
_: &str, F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
_: uint, {
f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
try!(write!(self.writer, "{{")); try!(write!(self.writer, "{{"));
try!(f(self)); try!(f(self));
write!(self.writer, "}}") write!(self.writer, "}}")
} }
fn emit_struct_field(&mut self, fn emit_struct_field<F>(&mut self, name: &str, idx: uint, f: F) -> EncodeResult where
name: &str, F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
idx: uint, {
f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
if idx != 0 { try!(write!(self.writer, ",")); } if idx != 0 { try!(write!(self.writer, ",")); }
try!(escape_str(self.writer, name)); try!(escape_str(self.writer, name));
try!(write!(self.writer, ":")); try!(write!(self.writer, ":"));
f(self) 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) self.emit_seq(len, f)
} }
fn emit_tuple_arg(&mut self, fn emit_tuple_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
idx: uint, F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult { {
self.emit_seq_elt(idx, f) self.emit_seq_elt(idx, f)
} }
fn emit_tuple_struct(&mut self, fn emit_tuple_struct<F>(&mut self, _name: &str, len: uint, f: F) -> EncodeResult where
_name: &str, F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
len: uint, {
f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
self.emit_seq(len, f) self.emit_seq(len, f)
} }
fn emit_tuple_struct_arg(&mut self, fn emit_tuple_struct_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
idx: uint, F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult { {
self.emit_seq_elt(idx, f) 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) f(self)
} }
fn emit_option_none(&mut self) -> EncodeResult { self.emit_nil() } 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) 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!(write!(self.writer, "["));
try!(f(self)); try!(f(self));
write!(self.writer, "]") 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 { if idx != 0 {
try!(write!(self.writer, ",")); try!(write!(self.writer, ","));
} }
f(self) 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!(write!(self.writer, "{{"));
try!(f(self)); try!(f(self));
write!(self.writer, "}}") write!(self.writer, "}}")
} }
fn emit_map_elt_key(&mut self, fn emit_map_elt_key<F>(&mut self, idx: uint, mut f: F) -> EncodeResult where
idx: uint, F: FnMut(&mut Encoder<'a>) -> EncodeResult,
f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult { {
if idx != 0 { try!(write!(self.writer, ",")) } if idx != 0 { try!(write!(self.writer, ",")) }
// ref #12967, make sure to wrap a key in double quotes, // ref #12967, make sure to wrap a key in double quotes,
// in the event that its of a type that omits them (eg numbers) // in the event that its of a type that omits them (eg numbers)
@ -594,9 +609,9 @@ impl<'a> ::Encoder<io::IoError> for Encoder<'a> {
Ok(()) Ok(())
} }
fn emit_map_elt_val(&mut self, fn emit_map_elt_val<F>(&mut self, _idx: uint, f: F) -> EncodeResult where
_idx: uint, F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult { {
try!(write!(self.writer, ":")); try!(write!(self.writer, ":"));
f(self) f(self)
} }
@ -663,17 +678,20 @@ impl<'a> ::Encoder<io::IoError> for PrettyEncoder<'a> {
escape_str(self.writer, v) escape_str(self.writer, v)
} }
fn emit_enum(&mut self, fn emit_enum<F>(&mut self, _name: &str, f: F) -> EncodeResult where
_name: &str, F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult { {
f(self) f(self)
} }
fn emit_enum_variant(&mut self, fn emit_enum_variant<F>(&mut self,
name: &str, name: &str,
_id: uint, _id: uint,
cnt: uint, cnt: uint,
f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult { f: F)
-> EncodeResult where
F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
{
if cnt == 0 { if cnt == 0 {
escape_str(self.writer, name) escape_str(self.writer, name)
} else { } else {
@ -697,9 +715,9 @@ impl<'a> ::Encoder<io::IoError> for PrettyEncoder<'a> {
} }
} }
fn emit_enum_variant_arg(&mut self, fn emit_enum_variant_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
idx: uint, F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult { {
if idx != 0 { if idx != 0 {
try!(write!(self.writer, ",\n")); try!(write!(self.writer, ",\n"));
} }
@ -707,26 +725,29 @@ impl<'a> ::Encoder<io::IoError> for PrettyEncoder<'a> {
f(self) f(self)
} }
fn emit_enum_struct_variant(&mut self, fn emit_enum_struct_variant<F>(&mut self,
name: &str, name: &str,
id: uint, id: uint,
cnt: uint, cnt: uint,
f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult { f: F) -> EncodeResult where
F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
{
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<F>(&mut self,
_: &str, _: &str,
idx: uint, idx: uint,
f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult { f: F) -> EncodeResult where
F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
{
self.emit_enum_variant_arg(idx, f) self.emit_enum_variant_arg(idx, f)
} }
fn emit_struct(&mut self, fn emit_struct<F>(&mut self, _: &str, len: uint, f: F) -> EncodeResult where
_: &str, F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
len: uint, {
f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
if len == 0 { if len == 0 {
write!(self.writer, "{{}}") write!(self.writer, "{{}}")
} else { } else {
@ -740,10 +761,9 @@ impl<'a> ::Encoder<io::IoError> for PrettyEncoder<'a> {
} }
} }
fn emit_struct_field(&mut self, fn emit_struct_field<F>(&mut self, name: &str, idx: uint, f: F) -> EncodeResult where
name: &str, F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
idx: uint, {
f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
if idx == 0 { if idx == 0 {
try!(write!(self.writer, "\n")); try!(write!(self.writer, "\n"));
} else { } else {
@ -755,40 +775,43 @@ impl<'a> ::Encoder<io::IoError> for PrettyEncoder<'a> {
f(self) f(self)
} }
fn emit_tuple(&mut self, fn emit_tuple<F>(&mut self, len: uint, f: F) -> EncodeResult where
len: uint, F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult { {
self.emit_seq(len, f) self.emit_seq(len, f)
} }
fn emit_tuple_arg(&mut self, fn emit_tuple_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
idx: uint, F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult { {
self.emit_seq_elt(idx, f) self.emit_seq_elt(idx, f)
} }
fn emit_tuple_struct(&mut self, fn emit_tuple_struct<F>(&mut self, _: &str, len: uint, f: F) -> EncodeResult where
_: &str, F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
len: uint, {
f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult {
self.emit_seq(len, f) self.emit_seq(len, f)
} }
fn emit_tuple_struct_arg(&mut self, fn emit_tuple_struct_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
idx: uint, F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult { {
self.emit_seq_elt(idx, f) 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) f(self)
} }
fn emit_option_none(&mut self) -> EncodeResult { self.emit_nil() } 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) f(self)
} }
fn emit_seq(&mut self, fn emit_seq<F>(&mut self, len: uint, f: F) -> EncodeResult where
len: uint, F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult { {
if len == 0 { if len == 0 {
write!(self.writer, "[]") write!(self.writer, "[]")
} else { } else {
@ -802,9 +825,9 @@ impl<'a> ::Encoder<io::IoError> for PrettyEncoder<'a> {
} }
} }
fn emit_seq_elt(&mut self, fn emit_seq_elt<F>(&mut self, idx: uint, f: F) -> EncodeResult where
idx: uint, F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult { {
if idx == 0 { if idx == 0 {
try!(write!(self.writer, "\n")); try!(write!(self.writer, "\n"));
} else { } else {
@ -814,9 +837,9 @@ impl<'a> ::Encoder<io::IoError> for PrettyEncoder<'a> {
f(self) f(self)
} }
fn emit_map(&mut self, fn emit_map<F>(&mut self, len: uint, f: F) -> EncodeResult where
len: uint, F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult { {
if len == 0 { if len == 0 {
write!(self.writer, "{{}}") write!(self.writer, "{{}}")
} else { } else {
@ -830,9 +853,9 @@ impl<'a> ::Encoder<io::IoError> for PrettyEncoder<'a> {
} }
} }
fn emit_map_elt_key(&mut self, fn emit_map_elt_key<F>(&mut self, idx: uint, mut f: F) -> EncodeResult where
idx: uint, F: FnMut(&mut PrettyEncoder<'a>) -> EncodeResult,
f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult { {
if idx == 0 { if idx == 0 {
try!(write!(self.writer, "\n")); try!(write!(self.writer, "\n"));
} else { } else {
@ -855,9 +878,9 @@ impl<'a> ::Encoder<io::IoError> for PrettyEncoder<'a> {
Ok(()) Ok(())
} }
fn emit_map_elt_val(&mut self, fn emit_map_elt_val<F>(&mut self, _idx: uint, f: F) -> EncodeResult where
_idx: uint, F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
f: |&mut PrettyEncoder<'a>| -> EncodeResult) -> EncodeResult { {
try!(write!(self.writer, ": ")); try!(write!(self.writer, ": "));
f(self) f(self)
} }
@ -2052,17 +2075,16 @@ impl ::Decoder<DecoderError> for Decoder {
expect!(self.pop(), String) expect!(self.pop(), String)
} }
fn read_enum<T>(&mut self, fn read_enum<T, F>(&mut self, name: &str, f: F) -> DecodeResult<T> where
name: &str, F: FnOnce(&mut Decoder) -> DecodeResult<T>,
f: |&mut Decoder| -> DecodeResult<T>) -> DecodeResult<T> { {
debug!("read_enum({})", name); debug!("read_enum({})", name);
f(self) f(self)
} }
fn read_enum_variant<T>(&mut self, fn read_enum_variant<T, F>(&mut self, names: &[&str], f: F) -> DecodeResult<T> where
names: &[&str], F: FnOnce(&mut Decoder, uint) -> DecodeResult<T>,
f: |&mut Decoder, uint| -> DecodeResult<T>) {
-> DecodeResult<T> {
debug!("read_enum_variant(names={})", names); debug!("read_enum_variant(names={})", names);
let name = match self.pop() { let name = match self.pop() {
Json::String(s) => s, Json::String(s) => s,
@ -2103,46 +2125,48 @@ impl ::Decoder<DecoderError> for Decoder {
f(self, idx) f(self, idx)
} }
fn read_enum_variant_arg<T>(&mut self, idx: uint, f: |&mut Decoder| -> DecodeResult<T>) fn read_enum_variant_arg<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
-> DecodeResult<T> { F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
debug!("read_enum_variant_arg(idx={})", idx); debug!("read_enum_variant_arg(idx={})", idx);
f(self) f(self)
} }
fn read_enum_struct_variant<T>(&mut self, fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> DecodeResult<T> where
names: &[&str], F: FnOnce(&mut Decoder, uint) -> DecodeResult<T>,
f: |&mut Decoder, uint| -> DecodeResult<T>) {
-> DecodeResult<T> {
debug!("read_enum_struct_variant(names={})", names); debug!("read_enum_struct_variant(names={})", names);
self.read_enum_variant(names, f) 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, name: &str,
idx: uint, idx: uint,
f: |&mut Decoder| -> DecodeResult<T>) f: F)
-> DecodeResult<T> { -> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
debug!("read_enum_struct_variant_field(name={}, idx={})", name, idx); debug!("read_enum_struct_variant_field(name={}, idx={})", name, idx);
self.read_enum_variant_arg(idx, f) self.read_enum_variant_arg(idx, f)
} }
fn read_struct<T>(&mut self, fn read_struct<T, F>(&mut self, name: &str, len: uint, f: F) -> DecodeResult<T> where
name: &str, F: FnOnce(&mut Decoder) -> DecodeResult<T>,
len: uint, {
f: |&mut Decoder| -> DecodeResult<T>)
-> DecodeResult<T> {
debug!("read_struct(name={}, len={})", name, len); debug!("read_struct(name={}, len={})", name, len);
let value = try!(f(self)); let value = try!(f(self));
self.pop(); self.pop();
Ok(value) Ok(value)
} }
fn read_struct_field<T>(&mut self, fn read_struct_field<T, F>(&mut self,
name: &str, name: &str,
idx: uint, idx: uint,
f: |&mut Decoder| -> DecodeResult<T>) f: F)
-> DecodeResult<T> { -> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
debug!("read_struct_field(name={}, idx={})", name, idx); debug!("read_struct_field(name={}, idx={})", name, idx);
let mut obj = try!(expect!(self.pop(), Object)); let mut obj = try!(expect!(self.pop(), Object));
@ -2165,12 +2189,11 @@ impl ::Decoder<DecoderError> for Decoder {
Ok(value) Ok(value)
} }
fn read_tuple<T>(&mut self, fn read_tuple<T, F>(&mut self, tuple_len: uint, f: F) -> DecodeResult<T> where
tuple_len: uint, F: FnOnce(&mut Decoder) -> DecodeResult<T>,
f: |&mut Decoder| -> DecodeResult<T>) {
-> DecodeResult<T> {
debug!("read_tuple()"); debug!("read_tuple()");
self.read_seq(|d, len| { self.read_seq(move |d, len| {
if len == tuple_len { if len == tuple_len {
f(d) f(d)
} else { } else {
@ -2179,31 +2202,37 @@ impl ::Decoder<DecoderError> for Decoder {
}) })
} }
fn read_tuple_arg<T>(&mut self, fn read_tuple_arg<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
idx: uint, F: FnOnce(&mut Decoder) -> DecodeResult<T>,
f: |&mut Decoder| -> DecodeResult<T>) -> DecodeResult<T> { {
debug!("read_tuple_arg(idx={})", idx); debug!("read_tuple_arg(idx={})", idx);
self.read_seq_elt(idx, f) self.read_seq_elt(idx, f)
} }
fn read_tuple_struct<T>(&mut self, fn read_tuple_struct<T, F>(&mut self,
name: &str, name: &str,
len: uint, len: uint,
f: |&mut Decoder| -> DecodeResult<T>) f: F)
-> DecodeResult<T> { -> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
debug!("read_tuple_struct(name={})", name); debug!("read_tuple_struct(name={})", name);
self.read_tuple(len, f) self.read_tuple(len, f)
} }
fn read_tuple_struct_arg<T>(&mut self, fn read_tuple_struct_arg<T, F>(&mut self,
idx: uint, idx: uint,
f: |&mut Decoder| -> DecodeResult<T>) f: F)
-> DecodeResult<T> { -> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
debug!("read_tuple_struct_arg(idx={})", idx); debug!("read_tuple_struct_arg(idx={})", idx);
self.read_tuple_arg(idx, f) 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()"); debug!("read_option()");
match self.pop() { match self.pop() {
Json::Null => f(self, false), Json::Null => f(self, false),
@ -2211,7 +2240,9 @@ impl ::Decoder<DecoderError> for Decoder {
} }
} }
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()"); debug!("read_seq()");
let array = try!(expect!(self.pop(), Array)); let array = try!(expect!(self.pop(), Array));
let len = array.len(); let len = array.len();
@ -2221,14 +2252,16 @@ impl ::Decoder<DecoderError> for Decoder {
f(self, len) f(self, len)
} }
fn read_seq_elt<T>(&mut self, fn read_seq_elt<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
idx: uint, F: FnOnce(&mut Decoder) -> DecodeResult<T>,
f: |&mut Decoder| -> DecodeResult<T>) -> DecodeResult<T> { {
debug!("read_seq_elt(idx={})", idx); debug!("read_seq_elt(idx={})", idx);
f(self) 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()"); debug!("read_map()");
let obj = try!(expect!(self.pop(), Object)); let obj = try!(expect!(self.pop(), Object));
let len = obj.len(); let len = obj.len();
@ -2239,14 +2272,16 @@ impl ::Decoder<DecoderError> for Decoder {
f(self, len) f(self, len)
} }
fn read_map_elt_key<T>(&mut self, idx: uint, f: |&mut Decoder| -> DecodeResult<T>) fn read_map_elt_key<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
-> DecodeResult<T> { F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
debug!("read_map_elt_key(idx={})", idx); debug!("read_map_elt_key(idx={})", idx);
f(self) f(self)
} }
fn read_map_elt_val<T>(&mut self, idx: uint, f: |&mut Decoder| -> DecodeResult<T>) fn read_map_elt_val<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
-> DecodeResult<T> { F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
debug!("read_map_elt_val(idx={})", idx); debug!("read_map_elt_val(idx={})", idx);
f(self) f(self)
} }

1
src/libserialize/lib.rs
View file

@ -24,6 +24,7 @@ Core encoding and decoding interfaces.
html_playground_url = "http://play.rust-lang.org/")] html_playground_url = "http://play.rust-lang.org/")]
#![allow(unknown_features)] #![allow(unknown_features)]
#![feature(macro_rules, default_type_params, phase, slicing_syntax, globs)] #![feature(macro_rules, default_type_params, phase, slicing_syntax, globs)]
#![feature(unboxed_closures)]
// test harness access // test harness access
#[cfg(test)] #[cfg(test)]

187
src/libserialize/serialize.rs
View file

@ -39,58 +39,61 @@ pub trait Encoder<E> {
fn emit_str(&mut self, v: &str) -> Result<(), E>; fn emit_str(&mut self, v: &str) -> Result<(), E>;
// Compound types: // Compound types:
fn emit_enum(&mut self, name: &str, 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(&mut self, fn emit_enum_variant<F>(&mut self, v_name: &str,
v_name: &str, v_id: uint,
v_id: uint, len: uint,
len: uint, f: F) -> Result<(), E> where
f: |&mut Self| -> Result<(), E>) -> Result<(), E>; F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_enum_variant_arg(&mut self, fn emit_enum_variant_arg<F>(&mut self, a_idx: uint, f: F) -> Result<(), E> where
a_idx: uint, F: FnOnce(&mut Self) -> Result<(), E>;
f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
fn emit_enum_struct_variant(&mut self, fn emit_enum_struct_variant<F>(&mut self, v_name: &str,
v_name: &str, v_id: uint,
v_id: uint, len: uint,
len: uint, f: F) -> Result<(), E> where
f: |&mut Self| -> Result<(), E>) -> Result<(), E>; F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_enum_struct_variant_field(&mut self, fn emit_enum_struct_variant_field<F>(&mut self,
f_name: &str, f_name: &str,
f_idx: uint, f_idx: uint,
f: |&mut Self| -> Result<(), E>) -> Result<(), E>; f: F) -> Result<(), E> where
F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_struct(&mut self, fn emit_struct<F>(&mut self, name: &str, len: uint, f: F) -> Result<(), E> where
name: &str, F: FnOnce(&mut Self) -> Result<(), E>;
len: uint, fn emit_struct_field<F>(&mut self, f_name: &str, f_idx: uint, f: F) -> Result<(), E> where
f: |&mut Self| -> Result<(), E>) -> Result<(), E>; F: FnOnce(&mut Self) -> 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<F>(&mut self, len: uint, f: F) -> Result<(), E> where
fn emit_tuple_arg(&mut self, idx: uint, f: |&mut Self| -> Result<(), E>) -> Result<(), E>; 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(&mut self, fn emit_tuple_struct<F>(&mut self, name: &str, len: uint, f: F) -> Result<(), E> where
name: &str, F: FnOnce(&mut Self) -> Result<(), E>;
len: uint, fn emit_tuple_struct_arg<F>(&mut self, f_idx: uint, f: F) -> Result<(), E> where
f: |&mut Self| -> Result<(), E>) -> Result<(), E>; F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_tuple_struct_arg(&mut self,
f_idx: uint,
f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
// Specialized types: // 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_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<F>(&mut self, len: uint, f: F) -> Result<(), E> where
fn emit_seq_elt(&mut self, idx: uint, f: |this: &mut Self| -> Result<(), E>) -> Result<(), E>; 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<F>(&mut self, len: uint, f: F) -> Result<(), E> where
fn emit_map_elt_key(&mut self, idx: uint, f: |&mut Self| -> Result<(), E>) -> Result<(), E>; F: FnOnce(&mut Self) -> Result<(), E>;
fn emit_map_elt_val(&mut self, idx: uint, f: |&mut Self| -> Result<(), E>) -> 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> { pub trait Decoder<E> {
@ -113,57 +116,57 @@ pub trait Decoder<E> {
fn read_str(&mut self) -> Result<String, E>; fn read_str(&mut self) -> Result<String, E>;
// Compound types: // Compound types:
fn read_enum<T>(&mut self, name: &str, 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>(&mut self, fn read_enum_variant<T, F>(&mut self, names: &[&str], f: F) -> Result<T, E> where
names: &[&str], F: FnOnce(&mut Self, uint) -> Result<T, E>;
f: |&mut Self, uint| -> Result<T, E>) fn read_enum_variant_arg<T, F>(&mut self, a_idx: uint, f: F) -> Result<T, E> where
-> Result<T, E>; F: FnOnce(&mut Self) -> 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, fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> Result<T, E> where
names: &[&str], F: FnOnce(&mut Self, uint) -> Result<T, E>;
f: |&mut Self, uint| -> Result<T, E>) fn read_enum_struct_variant_field<T, F>(&mut self,
-> Result<T, E>; &f_name: &str,
fn read_enum_struct_variant_field<T>(&mut self, f_idx: uint,
&f_name: &str, f: F)
f_idx: uint, -> Result<T, E> where
f: |&mut Self| -> Result<T, E>) F: FnOnce(&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>) fn read_struct<T, F>(&mut self, s_name: &str, len: uint, f: F) -> Result<T, E> where
-> Result<T, E>; F: FnOnce(&mut Self) -> Result<T, E>;
fn read_struct_field<T>(&mut self, fn read_struct_field<T, F>(&mut self,
f_name: &str, f_name: &str,
f_idx: uint, f_idx: uint,
f: |&mut Self| -> Result<T, E>) f: F)
-> Result<T, E>; -> Result<T, E> where
F: FnOnce(&mut Self) -> Result<T, E>;
fn read_tuple<T>(&mut self, len: uint, f: |&mut Self| -> Result<T, E>) -> Result<T, E>; fn read_tuple<T, F>(&mut self, len: uint, f: F) -> Result<T, E> where
fn read_tuple_arg<T>(&mut self, a_idx: uint, f: |&mut Self| -> Result<T, E>) -> Result<T, E>; 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>(&mut self, fn read_tuple_struct<T, F>(&mut self, s_name: &str, len: uint, f: F) -> Result<T, E> where
s_name: &str, F: FnOnce(&mut Self) -> Result<T, E>;
len: uint, fn read_tuple_struct_arg<T, F>(&mut self, a_idx: uint, f: F) -> Result<T, E> where
f: |&mut Self| -> Result<T, E>) F: FnOnce(&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>;
// Specialized types: // 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<T, F>(&mut self, f: F) -> Result<T, E> where
fn read_seq_elt<T>(&mut self, idx: uint, f: |&mut Self| -> Result<T, E>) -> Result<T, E>; 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<T, F>(&mut self, f: F) -> Result<T, E> where
fn read_map_elt_key<T>(&mut self, idx: uint, f: |&mut Self| -> Result<T, E>) -> Result<T, E>; F: FnOnce(&mut Self, uint) -> 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_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 // Failure
fn error(&mut self, err: &str) -> E; fn error(&mut self, err: &str) -> E;
@ -585,13 +588,14 @@ impl<E, D:Decoder<E>,T:Decodable<D, E>+Send+Sync> Decodable<D, E> for Arc<T> {
// Helper routines // Helper routines
pub trait EncoderHelpers<E> { pub trait EncoderHelpers<E> {
fn emit_from_vec<T>(&mut self, fn emit_from_vec<T, F>(&mut self, v: &[T], f: F) -> Result<(), E> where
v: &[T], F: FnMut(&mut Self, &T) -> Result<(), E>;
f: |&mut Self, v: &T| -> Result<(), E>) -> Result<(), E>;
} }
impl<E, S:Encoder<E>> EncoderHelpers<E> for S { 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| { self.emit_seq(v.len(), |this| {
for (i, e) in v.iter().enumerate() { for (i, e) in v.iter().enumerate() {
try!(this.emit_seq_elt(i, |this| { try!(this.emit_seq_elt(i, |this| {
@ -604,11 +608,14 @@ impl<E, S:Encoder<E>> EncoderHelpers<E> for S {
} }
pub trait DecoderHelpers<E> { 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 { 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| { self.read_seq(|this, len| {
let mut v = Vec::with_capacity(len); let mut v = Vec::with_capacity(len);
for i in range(0, len) { for i in range(0, len) {