Port serde2 to std::io, which cuts the speed by 26% :(

serde2/src/json/ser.rs

@@ -1,17 +1,16 @@
-use std::f64;
-use std::old_io::{self, ByRefWriter, IoError};
+use std::{f32, f64};
+use std::io;
 use std::num::{Float, FpCategory};
 use std::string::FromUtf8Error;
 
-use ser;
-use ser::Serializer;
+use ser::{self, Serializer};
 
 /// A structure for implementing serialization to JSON.
 pub struct Writer<W> {
     writer: W,
 }
 
-impl<W: old_io::Writer> Writer<W> {
+impl<W: io::Write> Writer<W> {
     /// Creates a new JSON visitr whose output will be written to the writer
     /// specified.
     #[inline]
@@ -28,14 +27,14 @@ impl<W: old_io::Writer> Writer<W> {
     }
 }
 
-impl<W: old_io::Writer> ser::Serializer for Writer<W> {
+impl<W: io::Write> ser::Serializer for Writer<W> {
     type Value = ();
-    type Error = IoError;
+    type Error = io::Error;
 
     #[inline]
     fn visit<
         T: ser::Serialize,
-    >(&mut self, value: &T) -> Result<(), IoError> {
+    >(&mut self, value: &T) -> io::Result<()> {
         value.visit(&mut Visitor { writer: &mut self.writer })
     }
 }
@@ -44,225 +43,263 @@ struct Visitor<'a, W: 'a> {
     writer: &'a mut W,
 }
 
-impl<'a, W: old_io::Writer> ser::Visitor for Visitor<'a, W> {
+impl<'a, W: io::Write> ser::Visitor for Visitor<'a, W> {
     type Value = ();
-    type Error = IoError;
+    type Error = io::Error;
 
     #[inline]
-    fn visit_unit(&mut self) -> Result<(), IoError> {
-        self.writer.write_str("null")
+    fn visit_unit(&mut self) -> io::Result<()> {
+        try!(self.writer.write(b"null"));
+        Ok(())
     }
 
     #[inline]
-    fn visit_bool(&mut self, value: bool) -> Result<(), IoError> {
+    fn visit_bool(&mut self, value: bool) -> io::Result<()> {
         if value {
-            self.writer.write_str("true")
+            try!(self.writer.write(b"true"));
         } else {
-            self.writer.write_str("false")
+            try!(self.writer.write(b"false"));
         }
+        Ok(())
     }
 
     #[inline]
-    fn visit_isize(&mut self, value: isize) -> Result<(), IoError> {
+    fn visit_isize(&mut self, value: isize) -> io::Result<()> {
         write!(self.writer, "{}", value)
     }
 
     #[inline]
-    fn visit_i8(&mut self, value: i8) -> Result<(), IoError> {
+    fn visit_i8(&mut self, value: i8) -> io::Result<()> {
         write!(self.writer, "{}", value)
     }
 
     #[inline]
-    fn visit_i16(&mut self, value: i16) -> Result<(), IoError> {
+    fn visit_i16(&mut self, value: i16) -> io::Result<()> {
         write!(self.writer, "{}", value)
     }
 
     #[inline]
-    fn visit_i32(&mut self, value: i32) -> Result<(), IoError> {
+    fn visit_i32(&mut self, value: i32) -> io::Result<()> {
         write!(self.writer, "{}", value)
     }
 
     #[inline]
-    fn visit_i64(&mut self, value: i64) -> Result<(), IoError> {
+    fn visit_i64(&mut self, value: i64) -> io::Result<()> {
         write!(self.writer, "{}", value)
     }
 
     #[inline]
-    fn visit_usize(&mut self, value: usize) -> Result<(), IoError> {
+    fn visit_usize(&mut self, value: usize) -> io::Result<()> {
         write!(self.writer, "{}", value)
     }
 
     #[inline]
-    fn visit_u8(&mut self, value: u8) -> Result<(), IoError> {
+    fn visit_u8(&mut self, value: u8) -> io::Result<()> {
         write!(self.writer, "{}", value)
     }
 
     #[inline]
-    fn visit_u16(&mut self, value: u16) -> Result<(), IoError> {
+    fn visit_u16(&mut self, value: u16) -> io::Result<()> {
         write!(self.writer, "{}", value)
     }
 
     #[inline]
-    fn visit_u32(&mut self, value: u32) -> Result<(), IoError> {
+    fn visit_u32(&mut self, value: u32) -> io::Result<()> {
         write!(self.writer, "{}", value)
     }
 
     #[inline]
-    fn visit_u64(&mut self, value: u64) -> Result<(), IoError> {
+    fn visit_u64(&mut self, value: u64) -> io::Result<()> {
         write!(self.writer, "{}", value)
     }
 
     #[inline]
-    fn visit_f64(&mut self, value: f64) -> Result<(), IoError> {
+    fn visit_f32(&mut self, value: f32) -> io::Result<()> {
+        fmt_f32_or_null(self.writer, value)
+    }
+
+    #[inline]
+    fn visit_f64(&mut self, value: f64) -> io::Result<()> {
         fmt_f64_or_null(self.writer, value)
     }
 
     #[inline]
-    fn visit_char(&mut self, v: char) -> Result<(), IoError> {
-        escape_char(self.writer, v)
+    fn visit_char(&mut self, value: char) -> io::Result<()> {
+        escape_char(self.writer, value)
     }
 
     #[inline]
-    fn visit_str(&mut self, value: &str) -> Result<(), IoError> {
+    fn visit_str(&mut self, value: &str) -> io::Result<()> {
         escape_str(self.writer, value)
     }
 
     #[inline]
-    fn visit_none(&mut self) -> Result<(), IoError> {
+    fn visit_none(&mut self) -> io::Result<()> {
         self.visit_unit()
     }
 
     #[inline]
-    fn visit_some<V>(&mut self, value: V) -> Result<(), IoError>
+    fn visit_some<V>(&mut self, value: V) -> io::Result<()>
         where V: ser::Serialize
     {
         value.visit(self)
     }
 
     #[inline]
-    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<(), IoError>
+    fn visit_seq<V>(&mut self, mut visitor: V) -> io::Result<()>
         where V: ser::SeqVisitor,
     {
-        try!(self.writer.write_str("["));
+        try!(self.writer.write(b"["));
 
         while let Some(()) = try!(visitor.visit(self)) { }
 
-        self.writer.write_str("]")
+        try!(self.writer.write(b"]"));
+        Ok(())
     }
 
     #[inline]
-    fn visit_seq_elt<T>(&mut self, first: bool, value: T) -> Result<(), IoError>
+    fn visit_seq_elt<T>(&mut self, first: bool, value: T) -> io::Result<()>
         where T: ser::Serialize,
     {
         if !first {
-            try!(self.writer.write_str(","));
+            try!(self.writer.write(b","));
         }
 
         value.visit(self)
     }
 
     #[inline]
-    fn visit_map<V>(&mut self, mut visitor: V) -> Result<(), IoError>
+    fn visit_map<V>(&mut self, mut visitor: V) -> io::Result<()>
         where V: ser::MapVisitor,
     {
-        try!(self.writer.write_str("{"));
+        try!(self.writer.write(b"{"));
 
         while let Some(()) = try!(visitor.visit(self)) { }
 
-        self.writer.write_str("}")
+        try!(self.writer.write(b"}"));
+
+        Ok(())
     }
 
     #[inline]
-    fn visit_map_elt<K, V>(&mut self, first: bool, key: K, value: V) -> Result<(), IoError>
+    fn visit_map_elt<K, V>(&mut self, first: bool, key: K, value: V) -> io::Result<()>
         where K: ser::Serialize,
               V: ser::Serialize,
     {
         if !first {
-            try!(self.writer.write_str(","));
+            try!(self.writer.write(b","));
         }
 
         try!(key.visit(self));
-        try!(self.writer.write_str(":"));
-        value.visit(self)
+        try!(self.writer.write(b":"));
+        try!(value.visit(self));
+        Ok(())
     }
 }
 
 #[inline]
-pub fn escape_bytes<W: old_io::Writer>(wr: &mut W, bytes: &[u8]) -> Result<(), IoError> {
-    try!(wr.write_str("\""));
+pub fn escape_bytes<W>(wr: &mut W, bytes: &[u8]) -> io::Result<()>
+    where W: io::Write
+{
+    try!(wr.write(b"\""));
 
     let mut start = 0;
 
     for (i, byte) in bytes.iter().enumerate() {
         let escaped = match *byte {
-            b'"' => "\\\"",
-            b'\\' => "\\\\",
-            b'\x08' => "\\b",
-            b'\x0c' => "\\f",
-            b'\n' => "\\n",
-            b'\r' => "\\r",
-            b'\t' => "\\t",
+            b'"' => b"\\\"",
+            b'\\' => b"\\\\",
+            b'\x08' => b"\\b",
+            b'\x0c' => b"\\f",
+            b'\n' => b"\\n",
+            b'\r' => b"\\r",
+            b'\t' => b"\\t",
             _ => { continue; }
         };
 
         if start < i {
-            try!(wr.write_all(&bytes[start..i]));
+            try!(wr.write(&bytes[start..i]));
         }
 
-        try!(wr.write_str(escaped));
+        try!(wr.write(escaped));
 
         start = i + 1;
     }
 
     if start != bytes.len() {
-        try!(wr.write_all(&bytes[start..]));
+        try!(wr.write(&bytes[start..]));
     }
 
-    wr.write_str("\"")
-}
-
-#[inline]
-pub fn escape_str<W: old_io::Writer>(wr: &mut W, value: &str) -> Result<(), IoError> {
-    escape_bytes(wr, value.as_bytes())
-}
-
-#[inline]
-pub fn escape_char<W: old_io::Writer>(wr: &mut W, value: char) -> Result<(), IoError> {
-    let mut buf = &mut [0; 4];
-    value.encode_utf8(buf);
-    escape_bytes(wr, buf)
-}
-
-fn fmt_f64_or_null<W: old_io::Writer>(wr: &mut W, value: f64) -> Result<(), IoError> {
-    match value.classify() {
-        FpCategory::Nan | FpCategory::Infinite => wr.write_str("null"),
-        _ => wr.write_str(&f64::to_str_digits(value, 6)),
-    }
-}
-
-#[inline]
-pub fn to_writer<W, T>(wr: &mut W, value: &T) -> Result<(), IoError>
-    where W: old_io::Writer,
-          T: ser::Serialize,
-{
-    let mut wr = Writer::new(wr.by_ref());
-    try!(wr.visit(value));
+    try!(wr.write(b"\""));
     Ok(())
 }
 
 #[inline]
-pub fn to_vec<T>(value: &T) -> Result<Vec<u8>, IoError>
-    where T: ser::Serialize,
+pub fn escape_str<W>(wr: &mut W, value: &str) -> io::Result<()>
+    where W: io::Write
 {
-    let mut wr = Vec::with_capacity(128);
-    to_writer(&mut wr, value).unwrap();
-    Ok(wr)
+    escape_bytes(wr, value.as_bytes())
 }
 
 #[inline]
-pub fn to_string<T>(value: &T) -> Result<Result<String, FromUtf8Error>, IoError>
+fn escape_char<W>(wr: &mut W, value: char) -> io::Result<()>
+    where W: io::Write
+{
+    let buf = &mut [0; 4];
+    value.encode_utf8(buf);
+    escape_bytes(wr, buf)
+}
+
+fn fmt_f32_or_null<W>(wr: &mut W, value: f32) -> io::Result<()>
+    where W: io::Write
+{
+    match value.classify() {
+        FpCategory::Nan | FpCategory::Infinite => try!(wr.write(b"null")),
+        _ => try!(wr.write(f32::to_str_digits(value, 6).as_bytes())),
+    };
+
+    Ok(())
+}
+
+fn fmt_f64_or_null<W>(wr: &mut W, value: f64) -> io::Result<()>
+    where W: io::Write
+{
+    match value.classify() {
+        FpCategory::Nan | FpCategory::Infinite => try!(wr.write(b"null")),
+        _ => try!(wr.write(f64::to_str_digits(value, 6).as_bytes())),
+    };
+
+    Ok(())
+}
+
+/// Encode the specified struct into a json `[u8]` writer.
+#[inline]
+pub fn to_writer<W, T>(writer: &mut W, value: &T) -> io::Result<()>
+    where W: io::Write,
+          T: ser::Serialize,
+{
+    let mut writer = Writer::new(writer);
+    try!(writer.visit(value));
+    Ok(())
+}
+
+/// Encode the specified struct into a json `[u8]` buffer.
+#[inline]
+pub fn to_vec<T>(value: &T) -> Vec<u8>
     where T: ser::Serialize,
 {
-    let vec = try!(to_vec(value));
-    Ok(String::from_utf8(vec))
+    // We are writing to a Vec, which doesn't fail. So we can ignore
+    // the error.
+    let mut writer = Vec::with_capacity(128);
+    to_writer(&mut writer, value).unwrap();
+    writer
+}
+
+/// Encode the specified struct into a json `String` buffer.
+#[inline]
+pub fn to_string<T>(value: &T) -> Result<String, FromUtf8Error>
+    where T: ser::Serialize
+{
+    let vec = to_vec(value);
+    String::from_utf8(vec)
 }

serde2/src/json/value.rs

@@ -1,6 +1,6 @@
 use std::collections::BTreeMap;
 use std::fmt;
-use std::old_io;
+use std::io;
 use std::str;
 
 use ser::{self, Serializer};
@@ -51,9 +51,16 @@ struct WriterFormatter<'a, 'b: 'a> {
     inner: &'a mut fmt::Formatter<'b>,
 }
 
-impl<'a, 'b> old_io::Writer for WriterFormatter<'a, 'b> {
-    fn write_all(&mut self, buf: &[u8]) -> old_io::IoResult<()> {
-        self.inner.write_str(str::from_utf8(buf).unwrap()).map_err(|_| old_io::IoError::last_error())
+impl<'a, 'b> io::Write for WriterFormatter<'a, 'b> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        match self.inner.write_str(str::from_utf8(buf).unwrap()) {
+            Ok(_) => Ok(buf.len()),
+            Err(_) => Err(io::Error::last_os_error()),
+        }
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
     }
 }