Update to the latest rustc-serialize

Cargo.toml

@@ -11,4 +11,4 @@ license = "MIT"
 description = "A binary serialization / deserialization strategy and implementation."
 
 [dependencies]
-rustc-serialize = "0.2.2"
+rustc-serialize = "0.2.5"

src/lib.rs

@@ -2,13 +2,13 @@
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![feature(old_orphan_check)]
+#![feature(associated_types)]
 
 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 rustc_serialize::Encodable;
 use rustc_serialize::Decodable;
@@ -25,8 +25,7 @@ pub enum SizeLimit {
     UpperBound(u64)
 }
 
-pub fn encode<'a, T>(t: &T, size_limit: SizeLimit) -> IoResult<Vec<u8>>
-where T: Encodable<EncoderWriter<'a, MemWriter>, IoError> {
+pub fn encode<T: Encodable>(t: &T, size_limit: SizeLimit) -> IoResult<Vec<u8>> {
     let mut w = MemWriter::new();
     match encode_into(t, &mut w, size_limit) {
         Ok(()) => Ok(w.into_inner()),
@@ -34,8 +33,7 @@ where T: Encodable<EncoderWriter<'a, MemWriter>, IoError> {
     }
 }
 
-pub fn decode<'a, T>(b: Vec<u8>, size_limit: SizeLimit) -> IoResult<T>
-where T: Decodable<DecoderReader<'a, MemReader>, IoError> {
+pub fn decode<T: Decodable>(b: Vec<u8>, size_limit: SizeLimit) -> IoResult<T> {
     decode_from(&mut MemReader::new(b), size_limit)
 }
 
@@ -43,19 +41,13 @@ where T: Decodable<DecoderReader<'a, MemReader>, IoError> {
 // the current json encoder in the stdlib
 
 // TODO: Make code safe https://github.com/rust-lang/rust/issues/14302
-pub fn encode_into<'a, W, T>(t: &T, w: &mut W, size_limit: SizeLimit) -> IoResult<()>
-where W: 'a + Writer, T: Encodable<EncoderWriter<'a, W>, IoError>{
-    unsafe {
-        t.encode(std::mem::transmute(&mut writer::EncoderWriter::new(w, size_limit)))
-    }
+pub fn encode_into<T: Encodable, W: Writer>(t: &T, w: &mut W, size_limit: SizeLimit) -> IoResult<()> {
+    t.encode(&mut writer::EncoderWriter::new(w, size_limit))
 }
 
 // TODO: Make code safe https://github.com/rust-lang/rust/issues/14302
-pub fn decode_from<'a, R, T>(r: &mut R, size_limit: SizeLimit) -> IoResult<T>
-where R: 'a + Reader + Buffer, T: Decodable<DecoderReader<'a, R>, IoError>{
-    unsafe {
-        Decodable::decode(std::mem::transmute(&mut reader::DecoderReader::new(r, size_limit)))
-    }
+pub fn decode_from<R: Reader+Buffer, T: Decodable>(r: &mut R, size_limit: SizeLimit) -> IoResult<T> {
+    Decodable::decode(&mut reader::DecoderReader::new(r, size_limit))
 }
 
 #[cfg(test)]

src/reader.rs

@@ -18,7 +18,9 @@ impl<'a, R: Reader+Buffer> DecoderReader<'a, R> {
     }
 }
 
-impl<'a, R: Reader+Buffer> Decoder<IoError> for DecoderReader<'a, R> {
+impl<'a, R: Reader+Buffer> Decoder for DecoderReader<'a, R> {
+    type Error = IoError;
+
     fn read_nil(&mut self) -> IoResult<()> {
         Ok(())
     }

src/test.rs

@@ -3,7 +3,6 @@ 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 rustc_serialize::{
@@ -14,18 +13,12 @@ use rustc_serialize::{
 };
 
 use super::{
-    EncoderWriter,
-    DecoderReader,
     encode,
     decode,
-    SizeLimit
 };
 use super::SizeLimit::Infinite;
 
-fn the_same<'a,
-            V: Encodable<EncoderWriter<'a, MemWriter>, IoError>  +
-               Decodable<DecoderReader<'a, MemReader>, IoError> +
-               PartialEq + Show>(element: V) {
+fn the_same<'a, V>(element: V) where V: Encodable, V: Decodable, V: PartialEq, V: Show {
     assert!(element == decode(encode(&element, Infinite).unwrap(), Infinite).unwrap());
 }
 

src/writer.rs

@@ -21,7 +21,9 @@ impl <'a, W: Writer> EncoderWriter<'a, W> {
     }
 }
 
-impl<'a, W: Writer> Encoder<IoError> for EncoderWriter<'a, W> {
+impl<'a, W: Writer> Encoder for EncoderWriter<'a, W> {
+    type Error = IoError;
+
     fn emit_nil(&mut self) -> EwResult { Ok(()) }
     fn emit_uint(&mut self, v: uint) -> EwResult {
         self.emit_u64(v as u64)