berkus
/
bincode-orig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update to latest rust nightly. 

- rustc 0.13.0-nightly (126db549b 2014-12-15 00:07:35 +0000)
This commit is contained in:
crhino 2014-12-15 20:28:42 -08:00
parent f3f849bbcc
commit 86d7094177
2 changed files with 166 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

159
src/reader.rs
View File

@ -70,85 +70,88 @@ impl<'a, R: Reader+Buffer> Decoder<IoError> for DecoderReader<'a, R> {
} }
Ok(String::from_utf8(vector).unwrap()) Ok(String::from_utf8(vector).unwrap())
} }
fn read_enum<T>(&mut self, _: &str, fn read_enum<T, F>(&mut self, name: &str, f: F) -> IoResult<T> where
f: |&mut DecoderReader<'a, R>| -> IoResult<T>) -> IoResult<T> { F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
f(self) f(self)
} }
fn read_enum_variant<T>(&mut self, _: &[&str], fn read_enum_variant<T, F>(&mut self, names: &[&str], f: F) -> IoResult<T> where
f: |&mut DecoderReader<'a, R>, uint| -> IoResult<T>) -> IoResult<T> { F: FnOnce(&mut DecoderReader<'a, R>, uint) -> IoResult<T> {
let id = try!(self.read_uint()); let id = try!(self.read_uint());
f(self, id) f(self, id)
} }
fn read_enum_variant_arg<T>(&mut self, _: uint, fn read_enum_variant_arg<T, F>(&mut self, a_idx: uint, f: F) -> IoResult<T> where
f: |&mut DecoderReader<'a, R>| -> IoResult<T>) -> IoResult<T> { F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
f(self) f(self)
} }
fn read_enum_struct_variant<T>(&mut self, names: &[&str], fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> IoResult<T> where
f: |&mut DecoderReader<'a, R>, uint| -> IoResult<T>) -> IoResult<T> { F: FnOnce(&mut DecoderReader<'a, R>, uint) -> IoResult<T> {
self.read_enum_variant(names, f) self.read_enum_variant(names, f)
} }
fn read_enum_struct_variant_field<T>(&mut self, _: &str, f_idx: uint, fn read_enum_struct_variant_field<T, F>(&mut self,
f: |&mut DecoderReader<'a, R>| -> IoResult<T>) -> IoResult<T> { _: &str,
self.read_enum_variant_arg(f_idx, f) f_idx: uint,
} f: F)
fn read_struct<T>(&mut self, _: &str, _: uint, -> IoResult<T> where
f: |&mut DecoderReader<'a, R>| -> IoResult<T>) -> IoResult<T> { F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
f(self) self.read_enum_variant_arg(f_idx, f)
} }
fn read_struct_field<T>(&mut self, _: &str, _: uint, fn read_struct<T, F>(&mut self, s_name: &str, len: uint, f: F) -> IoResult<T> where
f: |&mut DecoderReader<'a, R>| -> IoResult<T>) -> IoResult<T> { F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
f(self) f(self)
} }
fn read_tuple<T>(&mut self, _: uint, fn read_struct_field<T, F>(&mut self,
f: |&mut DecoderReader<'a, R>| -> IoResult<T>) -> f_name: &str,
IoResult<T> { f_idx: uint,
f(self) f: F)
} -> IoResult<T> where
fn read_tuple_arg<T>(&mut self, _: uint, F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
f: |&mut DecoderReader<'a, R>| -> IoResult<T>) -> IoResult<T> { f(self)
f(self) }
} fn read_tuple<T, F>(&mut self, len: uint, f: F) -> IoResult<T> where
fn read_tuple_struct<T>(&mut self, _: &str, len: uint, F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
f: |&mut DecoderReader<'a, R>| -> IoResult<T>) -> f(self)
IoResult<T> { }
self.read_tuple(len, f) fn read_tuple_arg<T, F>(&mut self, a_idx: uint, f: F) -> IoResult<T> where
} F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
fn read_tuple_struct_arg<T>(&mut self, a_idx: uint, f(self)
f: |&mut DecoderReader<'a, R>| -> IoResult<T>) -> IoResult<T> { }
self.read_tuple_arg(a_idx, f) fn read_tuple_struct<T, F>(&mut self, s_name: &str, len: uint, f: F) -> IoResult<T> where
} F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
fn read_option<T>(&mut self, self.read_tuple(len, f)
f: |&mut DecoderReader<'a, R>, bool| -> IoResult<T>) -> }
IoResult<T> { fn read_tuple_struct_arg<T, F>(&mut self, a_idx: uint, f: F) -> IoResult<T> where
match try!(self.reader.read_u8()) { F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
1 => f(self, true), self.read_tuple_arg(a_idx, f)
_ => f(self, false) }
fn read_option<T, F>(&mut self, f: F) -> IoResult<T> where
F: FnOnce(&mut DecoderReader<'a, R>, bool) -> IoResult<T> {
match try!(self.reader.read_u8()) {
1 => f(self, true),
_ => f(self, false)
}
}
fn read_seq<T, F>(&mut self, f: F) -> IoResult<T> where
F: FnOnce(&mut DecoderReader<'a, R>, uint) -> IoResult<T> {
let len = try!(self.read_uint());
f(self, len)
}
fn read_seq_elt<T, F>(&mut self, idx: uint, f: F) -> IoResult<T> where
F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
f(self)
}
fn read_map<T, F>(&mut self, f: F) -> IoResult<T> where
F: FnOnce(&mut DecoderReader<'a, R>, uint) -> IoResult<T> {
let len = try!(self.read_uint());
f(self, len)
}
fn read_map_elt_key<T, F>(&mut self, idx: uint, f: F) -> IoResult<T> where
F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
f(self)
}
fn read_map_elt_val<T, F>(&mut self, idx: uint, f: F) -> IoResult<T> where
F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult<T> {
f(self)
} }
}
fn read_seq<T>(&mut self,
f: |&mut DecoderReader<'a, R>, uint| -> IoResult<T>) ->
IoResult<T> {
let len = try!(self.read_uint());
f(self, len)
}
fn read_seq_elt<T>(&mut self, _: uint,
f: |&mut DecoderReader<'a, R>| -> IoResult<T>) -> IoResult<T> {
f(self)
}
fn read_map<T>(&mut self,
f: |&mut DecoderReader<'a, R>, uint| -> IoResult<T>) ->
IoResult<T> {
let len = try!(self.read_uint());
f(self, len)
}
fn read_map_elt_key<T>(&mut self, _: uint,
f: |&mut DecoderReader<'a, R>| -> IoResult<T>) -> IoResult<T> {
f(self)
}
fn read_map_elt_val<T>(&mut self, _: uint,
f: |&mut DecoderReader<'a, R>| -> IoResult<T>) -> IoResult<T> {
f(self)
}
fn error(&mut self, err: &str) -> IoError { fn error(&mut self, err: &str) -> IoError {
IoError { IoError {
kind: OtherIoError, kind: OtherIoError,

162
src/writer.rs
View File

@ -61,84 +61,92 @@ impl<'a, W: Writer> Encoder<IoError> for EncoderWriter<'a, W> {
try!(self.emit_uint(v.len())); try!(self.emit_uint(v.len()));
self.writer.write_str(v) self.writer.write_str(v)
} }
fn emit_enum(&mut self, _: &str, fn emit_enum<F>(&mut self, name: &str, f: F) -> EwResult where
f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
f(self) f(self)
} }
fn emit_enum_variant(&mut self, fn emit_enum_variant<F>(&mut self, v_name: &str,
_: &str, v_id: uint, _: uint, v_id: uint,
f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { len: uint,
try!(self.emit_uint(v_id)); f: F) -> EwResult where
f(self) F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
} try!(self.emit_uint(v_id));
fn emit_enum_variant_arg(&mut self, _: uint, f(self)
f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { }
f(self) fn emit_enum_variant_arg<F>(&mut self, a_idx: uint, f: F) -> EwResult where
} F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
fn emit_enum_struct_variant(&mut self, _: &str, _: uint, f(self)
_: uint, f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { }
f(self) fn emit_enum_struct_variant<F>(&mut self, v_name: &str,
} v_id: uint,
fn emit_enum_struct_variant_field(&mut self, _: &str, len: uint,
_: uint, f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { f: F) -> EwResult where
f(self) F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
} f(self)
fn emit_struct(&mut self, _: &str, _: uint, }
f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { fn emit_enum_struct_variant_field<F>(&mut self,
f(self) f_name: &str,
} f_idx: uint,
fn emit_struct_field(&mut self, _: &str, _: uint, f: F) -> EwResult where
f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
f(self) f(self)
} }
fn emit_tuple(&mut self, _: uint, fn emit_struct<F>(&mut self, name: &str, len: uint, f: F) -> EwResult where
f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
f(self) f(self)
} }
fn emit_tuple_arg(&mut self, _: uint, fn emit_struct_field<F>(&mut self, f_name: &str, f_idx: uint, f: F) -> EwResult where
f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
f(self) f(self)
} }
fn emit_tuple_struct(&mut self, _: &str, len: uint, fn emit_tuple<F>(&mut self, len: uint, f: F) -> EwResult where
f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
self.emit_tuple(len, f) f(self)
} }
fn emit_tuple_struct_arg(&mut self, f_idx: uint, fn emit_tuple_arg<F>(&mut self, idx: uint, f: F) -> EwResult where
f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
self.emit_tuple_arg(f_idx, f) f(self)
} }
fn emit_option(&mut self, fn emit_tuple_struct<F>(&mut self, name: &str, len: uint, f: F) -> EwResult where
f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
f(self) self.emit_tuple(len, f)
} }
fn emit_tuple_struct_arg<F>(&mut self, f_idx: uint, f: F) -> EwResult where
F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
self.emit_tuple_arg(f_idx, f)
}
fn emit_option<F>(&mut self, f: F) -> EwResult where
F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
f(self)
}
fn emit_option_none(&mut self) -> EwResult { fn emit_option_none(&mut self) -> EwResult {
self.writer.write_u8(0) self.writer.write_u8(0)
} }
fn emit_option_some(&mut self, fn emit_option_some<F>(&mut self, f: F) -> EwResult where
f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
try!(self.writer.write_u8(1)); try!(self.writer.write_u8(1));
f(self) f(self)
} }
fn emit_seq(&mut self, len: uint, fn emit_seq<F>(&mut self, len: uint, f: F) -> EwResult where
f: |this: &mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
try!(self.emit_uint(len)); try!(self.emit_uint(len));
f(self) f(self)
} }
fn emit_seq_elt(&mut self, _: uint, fn emit_seq_elt<F>(&mut self, idx: uint, f: F) -> EwResult where
f: |this: &mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
f(self) f(self)
} }
fn emit_map(&mut self, len: uint, fn emit_map<F>(&mut self, len: uint, f: F) -> EwResult where
f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
try!(self.emit_uint(len)); try!(self.emit_uint(len));
f(self) f(self)
} }
fn emit_map_elt_key(&mut self, _: uint, fn emit_map_elt_key<F>(&mut self, idx: uint, mut f: F) -> EwResult where
f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { F: FnMut(&mut EncoderWriter<'a, W>) -> EwResult {
f(self) f(self)
} }
fn emit_map_elt_val(&mut self, _: uint, fn emit_map_elt_val<F>(&mut self, idx: uint, f: F) -> EwResult where
f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult {
f(self) f(self)
} }
} }