prepare for the new io library

Cargo.toml

@@ -12,3 +12,6 @@ description = "A binary serialization / deserialization strategy and implementat
 
 [dependencies]
 rustc-serialize = "0.2.10"
+
+[dependencies.byteorder]
+git = "https://github.com/BurntSushi/byteorder.git"

src/lib.rs

@@ -5,6 +5,7 @@
 #![allow(unstable)]
 
 extern crate "rustc-serialize" as rustc_serialize;
+extern crate byteorder;
 
 use std::old_io::{Buffer, MemWriter};
 use rustc_serialize::{Encodable, Decodable};

src/reader.rs

@@ -5,6 +5,8 @@ use std::fmt;
 
 use rustc_serialize::Decoder;
 
+use byteorder::{BigEndian, ReaderBytesExt};
+
 use super::SizeLimit;
 
 #[derive(Eq, PartialEq, Clone, Debug)]
@@ -134,15 +136,15 @@ impl<'a, R: Buffer> Decoder for DecoderReader<'a, R> {
     }
     fn read_u64(&mut self) -> DecodingResult<u64> {
         try!(self.read_type::<u64>());
-        self.reader.read_be_u64().map_err(wrap_io)
+        self.reader.read_u64::<BigEndian>().map_err(wrap_io)
     }
     fn read_u32(&mut self) -> DecodingResult<u32> {
         try!(self.read_type::<u32>());
-        self.reader.read_be_u32().map_err(wrap_io)
+        self.reader.read_u32::<BigEndian>().map_err(wrap_io)
     }
     fn read_u16(&mut self) -> DecodingResult<u16> {
         try!(self.read_type::<u16>());
-        self.reader.read_be_u16().map_err(wrap_io)
+        self.reader.read_u16::<BigEndian>().map_err(wrap_io)
     }
     fn read_u8(&mut self) -> DecodingResult<u8> {
         try!(self.read_type::<u8>());
@@ -153,15 +155,15 @@ impl<'a, R: Buffer> Decoder for DecoderReader<'a, R> {
     }
     fn read_i64(&mut self) -> DecodingResult<i64> {
         try!(self.read_type::<i64>());
-        self.reader.read_be_i64().map_err(wrap_io)
+        self.reader.read_i64::<BigEndian>().map_err(wrap_io)
     }
     fn read_i32(&mut self) -> DecodingResult<i32> {
         try!(self.read_type::<i32>());
-        self.reader.read_be_i32().map_err(wrap_io)
+        self.reader.read_i32::<BigEndian>().map_err(wrap_io)
     }
     fn read_i16(&mut self) -> DecodingResult<i16> {
         try!(self.read_type::<i16>());
-        self.reader.read_be_i16().map_err(wrap_io)
+        self.reader.read_i16::<BigEndian>().map_err(wrap_io)
     }
     fn read_i8(&mut self) -> DecodingResult<i8> {
         try!(self.read_type::<i8>());
@@ -180,11 +182,11 @@ impl<'a, R: Buffer> Decoder for DecoderReader<'a, R> {
     }
     fn read_f64(&mut self) -> DecodingResult<f64> {
         try!(self.read_type::<f64>());
-        self.reader.read_be_f64().map_err(wrap_io)
+        self.reader.read_f64::<BigEndian>().map_err(wrap_io)
     }
     fn read_f32(&mut self) -> DecodingResult<f32> {
         try!(self.read_type::<f32>());
-        self.reader.read_be_f32().map_err(wrap_io)
+        self.reader.read_f32::<BigEndian>().map_err(wrap_io)
     }
     fn read_char(&mut self) -> DecodingResult<char> {
         let c = try!(self.reader.read_char().map_err(wrap_io));

src/writer.rs

@@ -4,6 +4,7 @@ use std::num::Int;
 use std::fmt;
 
 use rustc_serialize::Encoder;
+use byteorder::{BigEndian, WriterBytesExt};
 
 use super::SizeLimit;
 
@@ -105,13 +106,13 @@ impl<'a, W: Writer> Encoder for EncoderWriter<'a, W> {
         self.emit_u64(v as u64)
     }
     fn emit_u64(&mut self, v: u64) -> EncodingResult<()> {
-        self.writer.write_be_u64(v).map_err(wrap_io)
+        self.writer.write_u64::<BigEndian>(v).map_err(wrap_io)
     }
     fn emit_u32(&mut self, v: u32) -> EncodingResult<()> {
-        self.writer.write_be_u32(v).map_err(wrap_io)
+        self.writer.write_u32::<BigEndian>(v).map_err(wrap_io)
     }
     fn emit_u16(&mut self, v: u16) -> EncodingResult<()> {
-        self.writer.write_be_u16(v).map_err(wrap_io)
+        self.writer.write_u16::<BigEndian>(v).map_err(wrap_io)
     }
     fn emit_u8(&mut self, v: u8) -> EncodingResult<()> {
         self.writer.write_u8(v).map_err(wrap_io)
@@ -120,13 +121,13 @@ impl<'a, W: Writer> Encoder for EncoderWriter<'a, W> {
         self.emit_i64(v as i64)
     }
     fn emit_i64(&mut self, v: i64) -> EncodingResult<()> {
-        self.writer.write_be_i64(v).map_err(wrap_io)
+        self.writer.write_i64::<BigEndian>(v).map_err(wrap_io)
     }
     fn emit_i32(&mut self, v: i32) -> EncodingResult<()> {
-        self.writer.write_be_i32(v).map_err(wrap_io)
+        self.writer.write_i32::<BigEndian>(v).map_err(wrap_io)
     }
     fn emit_i16(&mut self, v: i16) -> EncodingResult<()> {
-        self.writer.write_be_i16(v).map_err(wrap_io)
+        self.writer.write_i16::<BigEndian>(v).map_err(wrap_io)
     }
     fn emit_i8(&mut self, v: i8) -> EncodingResult<()> {
         self.writer.write_i8(v).map_err(wrap_io)
@@ -135,13 +136,16 @@ impl<'a, W: Writer> Encoder for EncoderWriter<'a, W> {
         self.writer.write_u8(if v {1} else {0}).map_err(wrap_io)
     }
     fn emit_f64(&mut self, v: f64) -> EncodingResult<()> {
-        self.writer.write_be_f64(v).map_err(wrap_io)
+        self.writer.write_f64::<BigEndian>(v).map_err(wrap_io)
     }
     fn emit_f32(&mut self, v: f32) -> EncodingResult<()> {
-        self.writer.write_be_f32(v).map_err(wrap_io)
+        self.writer.write_f32::<BigEndian>(v).map_err(wrap_io)
     }
     fn emit_char(&mut self, v: char) -> EncodingResult<()> {
-        self.writer.write_char(v).map_err(wrap_io)
+        let mut cbuf = [0; 4];
+        let sz = v.encode_utf8(&mut cbuf[]).unwrap_or(0);
+        let ptr = &cbuf[..sz];
+        self.writer.write_all(ptr).map_err(wrap_io)
     }
     fn emit_str(&mut self, v: &str) -> EncodingResult<()> {
         try!(self.emit_usize(v.len()));