From 86d70941776a7e273239ed6db44adf6f8951d595 Mon Sep 17 00:00:00 2001 From: crhino Date: Mon, 15 Dec 2014 20:28:42 -0800 Subject: [PATCH 1/5] Update to latest rust nightly. - rustc 0.13.0-nightly (126db549b 2014-12-15 00:07:35 +0000) --- src/reader.rs | 159 +++++++++++++++++++++++++------------------------ src/writer.rs | 162 ++++++++++++++++++++++++++------------------------ 2 files changed, 166 insertions(+), 155 deletions(-) diff --git a/src/reader.rs b/src/reader.rs index 930dc9d..99d4ba3 100644 --- a/src/reader.rs +++ b/src/reader.rs @@ -70,85 +70,88 @@ impl<'a, R: Reader+Buffer> Decoder for DecoderReader<'a, R> { } Ok(String::from_utf8(vector).unwrap()) } - fn read_enum(&mut self, _: &str, - f: |&mut DecoderReader<'a, R>| -> IoResult) -> IoResult { - f(self) - } - fn read_enum_variant(&mut self, _: &[&str], - f: |&mut DecoderReader<'a, R>, uint| -> IoResult) -> IoResult { - let id = try!(self.read_uint()); - f(self, id) - } - fn read_enum_variant_arg(&mut self, _: uint, - f: |&mut DecoderReader<'a, R>| -> IoResult) -> IoResult { - f(self) - } - fn read_enum_struct_variant(&mut self, names: &[&str], - f: |&mut DecoderReader<'a, R>, uint| -> IoResult) -> IoResult { - self.read_enum_variant(names, f) - } - fn read_enum_struct_variant_field(&mut self, _: &str, f_idx: uint, - f: |&mut DecoderReader<'a, R>| -> IoResult) -> IoResult { - self.read_enum_variant_arg(f_idx, f) - } - fn read_struct(&mut self, _: &str, _: uint, - f: |&mut DecoderReader<'a, R>| -> IoResult) -> IoResult { - f(self) - } - fn read_struct_field(&mut self, _: &str, _: uint, - f: |&mut DecoderReader<'a, R>| -> IoResult) -> IoResult { - f(self) - } - fn read_tuple(&mut self, _: uint, - f: |&mut DecoderReader<'a, R>| -> IoResult) -> - IoResult { - f(self) - } - fn read_tuple_arg(&mut self, _: uint, - f: |&mut DecoderReader<'a, R>| -> IoResult) -> IoResult { - f(self) - } - fn read_tuple_struct(&mut self, _: &str, len: uint, - f: |&mut DecoderReader<'a, R>| -> IoResult) -> - IoResult { - self.read_tuple(len, f) - } - fn read_tuple_struct_arg(&mut self, a_idx: uint, - f: |&mut DecoderReader<'a, R>| -> IoResult) -> IoResult { - self.read_tuple_arg(a_idx, f) - } - fn read_option(&mut self, - f: |&mut DecoderReader<'a, R>, bool| -> IoResult) -> - IoResult { - match try!(self.reader.read_u8()) { - 1 => f(self, true), - _ => f(self, false) + fn read_enum(&mut self, name: &str, f: F) -> IoResult where + F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { + f(self) + } + fn read_enum_variant(&mut self, names: &[&str], f: F) -> IoResult where + F: FnOnce(&mut DecoderReader<'a, R>, uint) -> IoResult { + let id = try!(self.read_uint()); + f(self, id) + } + fn read_enum_variant_arg(&mut self, a_idx: uint, f: F) -> IoResult where + F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { + f(self) + } + fn read_enum_struct_variant(&mut self, names: &[&str], f: F) -> IoResult where + F: FnOnce(&mut DecoderReader<'a, R>, uint) -> IoResult { + self.read_enum_variant(names, f) + } + fn read_enum_struct_variant_field(&mut self, + _: &str, + f_idx: uint, + f: F) + -> IoResult where + F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { + self.read_enum_variant_arg(f_idx, f) + } + fn read_struct(&mut self, s_name: &str, len: uint, f: F) -> IoResult where + F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { + f(self) + } + fn read_struct_field(&mut self, + f_name: &str, + f_idx: uint, + f: F) + -> IoResult where + F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { + f(self) + } + fn read_tuple(&mut self, len: uint, f: F) -> IoResult where + F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { + f(self) + } + fn read_tuple_arg(&mut self, a_idx: uint, f: F) -> IoResult where + F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { + f(self) + } + fn read_tuple_struct(&mut self, s_name: &str, len: uint, f: F) -> IoResult where + F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { + self.read_tuple(len, f) + } + fn read_tuple_struct_arg(&mut self, a_idx: uint, f: F) -> IoResult where + F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { + self.read_tuple_arg(a_idx, f) + } + fn read_option(&mut self, f: F) -> IoResult where + F: FnOnce(&mut DecoderReader<'a, R>, bool) -> IoResult { + match try!(self.reader.read_u8()) { + 1 => f(self, true), + _ => f(self, false) + } + } + fn read_seq(&mut self, f: F) -> IoResult where + F: FnOnce(&mut DecoderReader<'a, R>, uint) -> IoResult { + let len = try!(self.read_uint()); + f(self, len) + } + fn read_seq_elt(&mut self, idx: uint, f: F) -> IoResult where + F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { + f(self) + } + fn read_map(&mut self, f: F) -> IoResult where + F: FnOnce(&mut DecoderReader<'a, R>, uint) -> IoResult { + let len = try!(self.read_uint()); + f(self, len) + } + fn read_map_elt_key(&mut self, idx: uint, f: F) -> IoResult where + F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { + f(self) + } + fn read_map_elt_val(&mut self, idx: uint, f: F) -> IoResult where + F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { + f(self) } - } - fn read_seq(&mut self, - f: |&mut DecoderReader<'a, R>, uint| -> IoResult) -> - IoResult { - let len = try!(self.read_uint()); - f(self, len) - } - fn read_seq_elt(&mut self, _: uint, - f: |&mut DecoderReader<'a, R>| -> IoResult) -> IoResult { - f(self) - } - fn read_map(&mut self, - f: |&mut DecoderReader<'a, R>, uint| -> IoResult) -> - IoResult { - let len = try!(self.read_uint()); - f(self, len) - } - fn read_map_elt_key(&mut self, _: uint, - f: |&mut DecoderReader<'a, R>| -> IoResult) -> IoResult { - f(self) - } - fn read_map_elt_val(&mut self, _: uint, - f: |&mut DecoderReader<'a, R>| -> IoResult) -> IoResult { - f(self) - } fn error(&mut self, err: &str) -> IoError { IoError { kind: OtherIoError, diff --git a/src/writer.rs b/src/writer.rs index 7b4be1f..88a518b 100644 --- a/src/writer.rs +++ b/src/writer.rs @@ -61,84 +61,92 @@ impl<'a, W: Writer> Encoder for EncoderWriter<'a, W> { try!(self.emit_uint(v.len())); self.writer.write_str(v) } - fn emit_enum(&mut self, _: &str, - f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { - f(self) - } - fn emit_enum_variant(&mut self, - _: &str, v_id: uint, _: uint, - f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { - try!(self.emit_uint(v_id)); - f(self) - } - fn emit_enum_variant_arg(&mut self, _: uint, - f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { - f(self) - } - fn emit_enum_struct_variant(&mut self, _: &str, _: uint, - _: uint, f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { - f(self) - } - fn emit_enum_struct_variant_field(&mut self, _: &str, - _: uint, f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { - f(self) - } - fn emit_struct(&mut self, _: &str, _: uint, - f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { - f(self) - } - fn emit_struct_field(&mut self, _: &str, _: uint, - f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { - f(self) - } - fn emit_tuple(&mut self, _: uint, - f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { - f(self) - } - fn emit_tuple_arg(&mut self, _: uint, - f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { - f(self) - } - fn emit_tuple_struct(&mut self, _: &str, len: uint, - f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { - self.emit_tuple(len, f) - } - fn emit_tuple_struct_arg(&mut self, f_idx: uint, - f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { - self.emit_tuple_arg(f_idx, f) - } - fn emit_option(&mut self, - f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { - f(self) - } + fn emit_enum(&mut self, name: &str, f: F) -> EwResult where + F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { + f(self) + } + fn emit_enum_variant(&mut self, v_name: &str, + v_id: uint, + len: uint, + f: F) -> EwResult where + F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { + try!(self.emit_uint(v_id)); + f(self) + } + fn emit_enum_variant_arg(&mut self, a_idx: uint, f: F) -> EwResult where + F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { + f(self) + } + fn emit_enum_struct_variant(&mut self, v_name: &str, + v_id: uint, + len: uint, + f: F) -> EwResult where + F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { + f(self) + } + fn emit_enum_struct_variant_field(&mut self, + f_name: &str, + f_idx: uint, + f: F) -> EwResult where + F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { + f(self) + } + fn emit_struct(&mut self, name: &str, len: uint, f: F) -> EwResult where + F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { + f(self) + } + fn emit_struct_field(&mut self, f_name: &str, f_idx: uint, f: F) -> EwResult where + F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { + f(self) + } + fn emit_tuple(&mut self, len: uint, f: F) -> EwResult where + F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { + f(self) + } + fn emit_tuple_arg(&mut self, idx: uint, f: F) -> EwResult where + F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { + f(self) + } + fn emit_tuple_struct(&mut self, name: &str, len: uint, f: F) -> EwResult where + F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { + self.emit_tuple(len, f) + } + fn emit_tuple_struct_arg(&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(&mut self, f: F) -> EwResult where + F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { + f(self) + } fn emit_option_none(&mut self) -> EwResult { self.writer.write_u8(0) } - fn emit_option_some(&mut self, - f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { - try!(self.writer.write_u8(1)); - f(self) - } - fn emit_seq(&mut self, len: uint, - f: |this: &mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { - try!(self.emit_uint(len)); - f(self) - } - fn emit_seq_elt(&mut self, _: uint, - f: |this: &mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { - f(self) - } - fn emit_map(&mut self, len: uint, - f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { - try!(self.emit_uint(len)); - f(self) - } - fn emit_map_elt_key(&mut self, _: uint, - f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { - f(self) - } - fn emit_map_elt_val(&mut self, _: uint, - f: |&mut EncoderWriter<'a, W>| -> EwResult) -> EwResult { - f(self) - } + fn emit_option_some(&mut self, f: F) -> EwResult where + F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { + try!(self.writer.write_u8(1)); + f(self) + } + fn emit_seq(&mut self, len: uint, f: F) -> EwResult where + F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { + try!(self.emit_uint(len)); + f(self) + } + fn emit_seq_elt(&mut self, idx: uint, f: F) -> EwResult where + F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { + f(self) + } + fn emit_map(&mut self, len: uint, f: F) -> EwResult where + F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { + try!(self.emit_uint(len)); + f(self) + } + fn emit_map_elt_key(&mut self, idx: uint, mut f: F) -> EwResult where + F: FnMut(&mut EncoderWriter<'a, W>) -> EwResult { + f(self) + } + fn emit_map_elt_val(&mut self, idx: uint, f: F) -> EwResult where + F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { + f(self) + } } From 1219fe8cf01a31bf0d1b753fb5f9bab6b8339a59 Mon Sep 17 00:00:00 2001 From: crhino Date: Mon, 15 Dec 2014 23:15:19 -0800 Subject: [PATCH 2/5] Fix rustc warnings. --- src/lib.rs | 2 +- src/reader.rs | 24 ++++++++++++------------ src/writer.rs | 34 +++++++++++++++++----------------- 3 files changed, 30 insertions(+), 30 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 8107139..ad60f47 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -21,7 +21,7 @@ mod reader; pub fn encode<'a, T: Encodable, IoError>>(t: &T) ->IoResult> { let mut w = MemWriter::new(); match encode_into(t, &mut w) { - Ok(()) => Ok(w.unwrap()), + Ok(()) => Ok(w.into_inner()), Err(e) => Err(e) } } diff --git a/src/reader.rs b/src/reader.rs index 99d4ba3..daa48a2 100644 --- a/src/reader.rs +++ b/src/reader.rs @@ -70,16 +70,16 @@ impl<'a, R: Reader+Buffer> Decoder for DecoderReader<'a, R> { } Ok(String::from_utf8(vector).unwrap()) } - fn read_enum(&mut self, name: &str, f: F) -> IoResult where + fn read_enum(&mut self, _: &str, f: F) -> IoResult where F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { f(self) } - fn read_enum_variant(&mut self, names: &[&str], f: F) -> IoResult where + fn read_enum_variant(&mut self, _: &[&str], f: F) -> IoResult where F: FnOnce(&mut DecoderReader<'a, R>, uint) -> IoResult { let id = try!(self.read_uint()); f(self, id) } - fn read_enum_variant_arg(&mut self, a_idx: uint, f: F) -> IoResult where + fn read_enum_variant_arg(&mut self, _: uint, f: F) -> IoResult where F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { f(self) } @@ -95,27 +95,27 @@ impl<'a, R: Reader+Buffer> Decoder for DecoderReader<'a, R> { F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { self.read_enum_variant_arg(f_idx, f) } - fn read_struct(&mut self, s_name: &str, len: uint, f: F) -> IoResult where + fn read_struct(&mut self, _: &str, _: uint, f: F) -> IoResult where F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { f(self) } fn read_struct_field(&mut self, - f_name: &str, - f_idx: uint, + _: &str, + _: uint, f: F) -> IoResult where F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { f(self) } - fn read_tuple(&mut self, len: uint, f: F) -> IoResult where + fn read_tuple(&mut self, _: uint, f: F) -> IoResult where F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { f(self) } - fn read_tuple_arg(&mut self, a_idx: uint, f: F) -> IoResult where + fn read_tuple_arg(&mut self, _: uint, f: F) -> IoResult where F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { f(self) } - fn read_tuple_struct(&mut self, s_name: &str, len: uint, f: F) -> IoResult where + fn read_tuple_struct(&mut self, _: &str, len: uint, f: F) -> IoResult where F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { self.read_tuple(len, f) } @@ -135,7 +135,7 @@ impl<'a, R: Reader+Buffer> Decoder for DecoderReader<'a, R> { let len = try!(self.read_uint()); f(self, len) } - fn read_seq_elt(&mut self, idx: uint, f: F) -> IoResult where + fn read_seq_elt(&mut self, _: uint, f: F) -> IoResult where F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { f(self) } @@ -144,11 +144,11 @@ impl<'a, R: Reader+Buffer> Decoder for DecoderReader<'a, R> { let len = try!(self.read_uint()); f(self, len) } - fn read_map_elt_key(&mut self, idx: uint, f: F) -> IoResult where + fn read_map_elt_key(&mut self, _: uint, f: F) -> IoResult where F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { f(self) } - fn read_map_elt_val(&mut self, idx: uint, f: F) -> IoResult where + fn read_map_elt_val(&mut self, _: uint, f: F) -> IoResult where F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { f(self) } diff --git a/src/writer.rs b/src/writer.rs index 88a518b..7c27ace 100644 --- a/src/writer.rs +++ b/src/writer.rs @@ -61,53 +61,53 @@ impl<'a, W: Writer> Encoder for EncoderWriter<'a, W> { try!(self.emit_uint(v.len())); self.writer.write_str(v) } - fn emit_enum(&mut self, name: &str, f: F) -> EwResult where + fn emit_enum(&mut self, __: &str, f: F) -> EwResult where F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { f(self) } - fn emit_enum_variant(&mut self, v_name: &str, + fn emit_enum_variant(&mut self, _: &str, v_id: uint, - len: uint, + _: uint, f: F) -> EwResult where F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { try!(self.emit_uint(v_id)); f(self) } - fn emit_enum_variant_arg(&mut self, a_idx: uint, f: F) -> EwResult where + fn emit_enum_variant_arg(&mut self, _: uint, f: F) -> EwResult where F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { f(self) } - fn emit_enum_struct_variant(&mut self, v_name: &str, - v_id: uint, - len: uint, + fn emit_enum_struct_variant(&mut self, _: &str, + _: uint, + _: uint, f: F) -> EwResult where F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { f(self) } fn emit_enum_struct_variant_field(&mut self, - f_name: &str, - f_idx: uint, + _: &str, + _: uint, f: F) -> EwResult where F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { f(self) } - fn emit_struct(&mut self, name: &str, len: uint, f: F) -> EwResult where + fn emit_struct(&mut self, _: &str, _: uint, f: F) -> EwResult where F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { f(self) } - fn emit_struct_field(&mut self, f_name: &str, f_idx: uint, f: F) -> EwResult where + fn emit_struct_field(&mut self, _: &str, _: uint, f: F) -> EwResult where F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { f(self) } - fn emit_tuple(&mut self, len: uint, f: F) -> EwResult where + fn emit_tuple(&mut self, _: uint, f: F) -> EwResult where F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { f(self) } - fn emit_tuple_arg(&mut self, idx: uint, f: F) -> EwResult where + fn emit_tuple_arg(&mut self, _: uint, f: F) -> EwResult where F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { f(self) } - fn emit_tuple_struct(&mut self, name: &str, len: uint, f: F) -> EwResult where + fn emit_tuple_struct(&mut self, _: &str, len: uint, f: F) -> EwResult where F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { self.emit_tuple(len, f) } @@ -132,7 +132,7 @@ impl<'a, W: Writer> Encoder for EncoderWriter<'a, W> { try!(self.emit_uint(len)); f(self) } - fn emit_seq_elt(&mut self, idx: uint, f: F) -> EwResult where + fn emit_seq_elt(&mut self, _: uint, f: F) -> EwResult where F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { f(self) } @@ -141,11 +141,11 @@ impl<'a, W: Writer> Encoder for EncoderWriter<'a, W> { try!(self.emit_uint(len)); f(self) } - fn emit_map_elt_key(&mut self, idx: uint, mut f: F) -> EwResult where + fn emit_map_elt_key(&mut self, _: uint, mut f: F) -> EwResult where F: FnMut(&mut EncoderWriter<'a, W>) -> EwResult { f(self) } - fn emit_map_elt_val(&mut self, idx: uint, f: F) -> EwResult where + fn emit_map_elt_val(&mut self, _: uint, f: F) -> EwResult where F: FnOnce(&mut EncoderWriter<'a, W>) -> EwResult { f(self) } From 7e7bd12479cd4b9d3db91d009f1f5e556d540e2a Mon Sep 17 00:00:00 2001 From: crhino Date: Wed, 24 Dec 2014 12:22:15 -0500 Subject: [PATCH 3/5] Change closures to FnMut to correspond to change in serialize crate. --- src/reader.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/reader.rs b/src/reader.rs index daa48a2..b264643 100644 --- a/src/reader.rs +++ b/src/reader.rs @@ -74,8 +74,8 @@ impl<'a, R: Reader+Buffer> Decoder for DecoderReader<'a, R> { F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { f(self) } - fn read_enum_variant(&mut self, _: &[&str], f: F) -> IoResult where - F: FnOnce(&mut DecoderReader<'a, R>, uint) -> IoResult { + fn read_enum_variant(&mut self, _: &[&str], mut f: F) -> IoResult where + F: FnMut(&mut DecoderReader<'a, R>, uint) -> IoResult { let id = try!(self.read_uint()); f(self, id) } @@ -84,7 +84,7 @@ impl<'a, R: Reader+Buffer> Decoder for DecoderReader<'a, R> { f(self) } fn read_enum_struct_variant(&mut self, names: &[&str], f: F) -> IoResult where - F: FnOnce(&mut DecoderReader<'a, R>, uint) -> IoResult { + F: FnMut(&mut DecoderReader<'a, R>, uint) -> IoResult { self.read_enum_variant(names, f) } fn read_enum_struct_variant_field(&mut self, @@ -123,8 +123,8 @@ impl<'a, R: Reader+Buffer> Decoder for DecoderReader<'a, R> { F: FnOnce(&mut DecoderReader<'a, R>) -> IoResult { self.read_tuple_arg(a_idx, f) } - fn read_option(&mut self, f: F) -> IoResult where - F: FnOnce(&mut DecoderReader<'a, R>, bool) -> IoResult { + fn read_option(&mut self, mut f: F) -> IoResult where + F: FnMut(&mut DecoderReader<'a, R>, bool) -> IoResult { match try!(self.reader.read_u8()) { 1 => f(self, true), _ => f(self, false) From 8f982f334ef2c58565af017c94476cb560616834 Mon Sep 17 00:00:00 2001 From: crhino Date: Wed, 24 Dec 2014 12:23:23 -0500 Subject: [PATCH 4/5] serialize crate has moved out of tree to rustc-serialize. See commit https://github.com/rust-lang/rust/commit/b04bc5cc49a398df712092a68ab9ad83019498ad --- Cargo.toml | 3 +++ examples/basic.rs | 6 +++--- src/lib.rs | 6 +++--- src/reader.rs | 2 +- src/test.rs | 16 +++++++++------- src/writer.rs | 2 +- 6 files changed, 20 insertions(+), 15 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 6aead0f..1dbe653 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,3 +9,6 @@ keywords = ["binary", "encode", "decode", "serialize", "deserialize"] license = "MIT" description = "A binary serialization / deserialization strategy and implementation." + +[dependencies] +rustc-serialize = "0.1.4" diff --git a/examples/basic.rs b/examples/basic.rs index eaf103e..0eaf978 100644 --- a/examples/basic.rs +++ b/examples/basic.rs @@ -1,13 +1,13 @@ extern crate bincode; -extern crate serialize; +extern crate "rustc-serialize" as rustc_serialize; -#[deriving(Encodable, Decodable, PartialEq)] +#[deriving(RustcEncodable, RustcDecodable, PartialEq)] struct Entity { x: f32, y: f32, } -#[deriving(Encodable, Decodable, PartialEq)] +#[deriving(RustcEncodable, RustcDecodable, PartialEq)] struct World { entities: Vec } diff --git a/src/lib.rs b/src/lib.rs index ad60f47..82baa19 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -2,15 +2,15 @@ #![crate_type = "rlib"] #![crate_type = "dylib"] -extern crate serialize; +extern crate "rustc-serialize" as rustc_serialize; use std::io::Buffer; use std::io::MemWriter; use std::io::MemReader; use std::io::IoError; use std::io::IoResult; -use serialize::Encodable; -use serialize::Decodable; +use rustc_serialize::Encodable; +use rustc_serialize::Decodable; pub use writer::EncoderWriter; pub use reader::DecoderReader; diff --git a/src/reader.rs b/src/reader.rs index b264643..6c04648 100644 --- a/src/reader.rs +++ b/src/reader.rs @@ -1,5 +1,5 @@ use std::io::{Buffer, Reader, IoError, IoResult, OtherIoError}; -use serialize::Decoder; +use rustc_serialize::Decoder; pub struct DecoderReader<'a, R: 'a> { reader: &'a mut R diff --git a/src/test.rs b/src/test.rs index b2e3b9a..3485a34 100644 --- a/src/test.rs +++ b/src/test.rs @@ -1,10 +1,12 @@ +extern crate "rustc-serialize" as serialize; + use std::io::MemWriter; use std::fmt::Show; use std::io::MemReader; use std::io::IoError; use std::collections::HashMap; -use serialize::{ +use rustc_serialize::{ Encoder, Decoder, Encodable, @@ -63,7 +65,7 @@ fn test_tuple() { #[test] fn test_basic_struct() { - #[deriving(Encodable, Decodable, PartialEq, Show)] + #[deriving(RustcEncodable, RustcDecodable, PartialEq, Show)] struct Easy { x: int, s: String, @@ -74,13 +76,13 @@ fn test_basic_struct() { #[test] fn test_nested_struct() { - #[deriving(Encodable, Decodable, PartialEq, Show)] + #[deriving(RustcEncodable, RustcDecodable, PartialEq, Show)] struct Easy { x: int, s: String, y: uint } - #[deriving(Encodable, Decodable, PartialEq, Show)] + #[deriving(RustcEncodable, RustcDecodable, PartialEq, Show)] struct Nest { f: Easy, b: uint, @@ -96,7 +98,7 @@ fn test_nested_struct() { #[test] fn test_struct_tuple() { - #[deriving(Encodable, Decodable, PartialEq, Show)] + #[deriving(RustcEncodable, RustcDecodable, PartialEq, Show)] struct TubStr(uint, String, f32); the_same(TubStr(5, "hello".to_string(), 3.2)); @@ -111,7 +113,7 @@ fn option() { #[test] fn enm() { - #[deriving(Encodable, Decodable, PartialEq, Show)] + #[deriving(RustcEncodable, RustcDecodable, PartialEq, Show)] enum TestEnum { NoArg, OneArg(uint), @@ -125,7 +127,7 @@ fn enm() { #[test] fn struct_enum() { - #[deriving(Encodable, Decodable, PartialEq, Show)] + #[deriving(RustcEncodable, RustcDecodable, PartialEq, Show)] enum TestEnum { NoArg, OneArg(uint), diff --git a/src/writer.rs b/src/writer.rs index 7c27ace..ac61687 100644 --- a/src/writer.rs +++ b/src/writer.rs @@ -1,5 +1,5 @@ use std::io::{Writer, IoError, IoResult}; -use serialize::Encoder; +use rustc_serialize::Encoder; type EwResult = IoResult<()>; From 74d9d9b1afe2a7c650d2154ccc93b6b6e63364a0 Mon Sep 17 00:00:00 2001 From: crhino Date: Wed, 24 Dec 2014 12:31:47 -0500 Subject: [PATCH 5/5] Update version to 0.0.3 --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 1dbe653..cd00acc 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "bincode" -version = "0.0.2" +version = "0.0.3" authors = ["Ty Overby "] repository = "https://github.com/TyOverby/bincode"