pull the json serializer into it's own module

src/json/ser.rs

@@ -0,0 +1,634 @@
+use std::f32;
+use std::f64;
+use std::num::{FPNaN, FPInfinite};
+use std::io::{IoError, IoResult, MemWriter};
+
+use ser::Serialize;
+use ser;
+
+fn escape_bytes<W: Writer>(wr: &mut W, bytes: &[u8]) -> IoResult<()> {
+    try!(wr.write_str("\""));
+
+    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",
+            _ => { continue; }
+        };
+
+        if start < i {
+            try!(wr.write(bytes.slice(start, i)));
+        }
+
+        try!(wr.write_str(escaped));
+
+        start = i + 1;
+    }
+
+    if start != bytes.len() {
+        try!(wr.write(bytes.slice_from(start)));
+    }
+
+    wr.write_str("\"")
+}
+
+pub fn escape_str<W: Writer>(wr: &mut W, v: &str) -> IoResult<()> {
+    escape_bytes(wr, v.as_bytes())
+}
+
+fn escape_char<W: Writer>(wr: &mut W, v: char) -> IoResult<()> {
+    let mut buf = [0, .. 4];
+    v.encode_utf8(buf);
+    escape_bytes(wr, buf)
+}
+
+fn fmt_f32_or_null<W: Writer>(wr: &mut W, v: f32) -> IoResult<()> {
+    match v.classify() {
+        FPNaN | FPInfinite => wr.write_str("null"),
+        _ => wr.write_str(f32::to_str_digits(v, 6).as_slice()),
+    }
+}
+
+fn fmt_f64_or_null<W: Writer>(wr: &mut W, v: f64) -> IoResult<()> {
+    match v.classify() {
+        FPNaN | FPInfinite => wr.write_str("null"),
+        _ => wr.write_str(f64::to_str_digits(v, 6).as_slice()),
+    }
+}
+
+fn spaces<W: Writer>(wr: &mut W, mut n: uint) -> IoResult<()> {
+    const LEN: uint = 16;
+    const BUF: [u8, ..LEN] = [b' ', ..LEN];
+
+    while n >= LEN {
+        try!(wr.write(BUF));
+        n -= LEN;
+    }
+
+    if n > 0 {
+        wr.write(BUF.slice_to(n))
+    } else {
+        Ok(())
+    }
+}
+
+/*
+#[deriving(Show)]
+enum SerializerState {
+    ValueState,
+    TupleState,
+    StructState,
+    EnumState,
+}
+*/
+
+/// A structure for implementing serialization to JSON.
+pub struct Serializer<W> {
+    wr: W,
+    first: bool,
+}
+
+impl<W: Writer> Serializer<W> {
+    /// Creates a new JSON serializer whose output will be written to the writer
+    /// specified.
+    pub fn new(wr: W) -> Serializer<W> {
+        Serializer {
+            wr: wr,
+            first: true,
+        }
+    }
+
+    /// Unwrap the Writer from the Serializer.
+    pub fn unwrap(self) -> W {
+        self.wr
+    }
+}
+
+impl<W: Writer> ser::Serializer<IoError> for Serializer<W> {
+    #[inline]
+    fn serialize_null(&mut self) -> IoResult<()> {
+        self.wr.write_str("null")
+    }
+
+    #[inline]
+    fn serialize_bool(&mut self, v: bool) -> IoResult<()> {
+        if v {
+            self.wr.write_str("true")
+        } else {
+            self.wr.write_str("false")
+        }
+    }
+
+    #[inline]
+    fn serialize_int(&mut self, v: int) -> IoResult<()> {
+        write!(self.wr, "{}", v)
+    }
+
+    #[inline]
+    fn serialize_i8(&mut self, v: i8) -> IoResult<()> {
+        write!(self.wr, "{}", v)
+    }
+
+    #[inline]
+    fn serialize_i16(&mut self, v: i16) -> IoResult<()> {
+        write!(self.wr, "{}", v)
+    }
+
+    #[inline]
+    fn serialize_i32(&mut self, v: i32) -> IoResult<()> {
+        write!(self.wr, "{}", v)
+    }
+
+    #[inline]
+    fn serialize_i64(&mut self, v: i64) -> IoResult<()> {
+        write!(self.wr, "{}", v)
+    }
+
+    #[inline]
+    fn serialize_uint(&mut self, v: uint) -> IoResult<()> {
+        write!(self.wr, "{}", v)
+    }
+
+    #[inline]
+    fn serialize_u8(&mut self, v: u8) -> IoResult<()> {
+        write!(self.wr, "{}", v)
+    }
+
+    #[inline]
+    fn serialize_u16(&mut self, v: u16) -> IoResult<()> {
+        write!(self.wr, "{}", v)
+    }
+
+    #[inline]
+    fn serialize_u32(&mut self, v: u32) -> IoResult<()> {
+        write!(self.wr, "{}", v)
+    }
+
+    #[inline]
+    fn serialize_u64(&mut self, v: u64) -> IoResult<()> {
+        write!(self.wr, "{}", v)
+    }
+
+    #[inline]
+    fn serialize_f32(&mut self, v: f32) -> IoResult<()> {
+        fmt_f32_or_null(&mut self.wr, v)
+    }
+
+    #[inline]
+    fn serialize_f64(&mut self, v: f64) -> IoResult<()> {
+        fmt_f64_or_null(&mut self.wr, v)
+    }
+
+    #[inline]
+    fn serialize_char(&mut self, v: char) -> IoResult<()> {
+        escape_char(&mut self.wr, v)
+    }
+
+    #[inline]
+    fn serialize_str(&mut self, v: &str) -> IoResult<()> {
+        escape_str(&mut self.wr, v)
+    }
+
+    #[inline]
+    fn serialize_tuple_start(&mut self, _len: uint) -> IoResult<()> {
+        self.first = true;
+        self.wr.write_str("[")
+    }
+
+    #[inline]
+    fn serialize_tuple_elt<
+        T: Serialize<Serializer<W>, IoError>
+    >(&mut self, value: &T) -> IoResult<()> {
+        if self.first {
+            self.first = false;
+        } else {
+            try!(self.wr.write_str(","));
+        }
+        value.serialize(self)
+    }
+
+    #[inline]
+    fn serialize_tuple_end(&mut self) -> IoResult<()> {
+        self.wr.write_str("]")
+    }
+
+    #[inline]
+    fn serialize_struct_start(&mut self, _name: &str, _len: uint) -> IoResult<()> {
+        self.first = true;
+        self.wr.write_str("{")
+    }
+
+    #[inline]
+    fn serialize_struct_elt<
+        T: Serialize<Serializer<W>, IoError>
+    >(&mut self, name: &str, value: &T) -> IoResult<()> {
+        if self.first {
+            self.first = false;
+        } else {
+            try!(self.wr.write_str(","));
+        }
+        try!(name.serialize(self));
+        try!(self.wr.write_str(":"));
+        value.serialize(self)
+    }
+
+    #[inline]
+    fn serialize_struct_end(&mut self) -> IoResult<()> {
+        self.wr.write_str("}")
+    }
+
+    #[inline]
+    fn serialize_enum_start(&mut self, _name: &str, variant: &str, _len: uint) -> IoResult<()> {
+        self.first = true;
+        try!(self.wr.write_str("{"));
+        try!(self.serialize_str(variant));
+        self.wr.write_str(":[")
+    }
+
+    #[inline]
+    fn serialize_enum_elt<
+        T: Serialize<Serializer<W>, IoError>
+    >(&mut self, value: &T) -> IoResult<()> {
+        if self.first {
+            self.first = false;
+        } else {
+            try!(self.wr.write_str(","));
+        }
+        value.serialize(self)
+    }
+
+    #[inline]
+    fn serialize_enum_end(&mut self) -> IoResult<()> {
+        self.wr.write_str("]}")
+    }
+
+    #[inline]
+    fn serialize_option<
+        T: Serialize<Serializer<W>, IoError>
+    >(&mut self, v: &Option<T>) -> IoResult<()> {
+        match *v {
+            Some(ref v) => {
+                v.serialize(self)
+            }
+            None => {
+                self.serialize_null()
+            }
+        }
+    }
+
+    #[inline]
+    fn serialize_seq<
+        T: Serialize<Serializer<W>, IoError>,
+        Iter: Iterator<T>
+    >(&mut self, mut iter: Iter) -> IoResult<()> {
+        try!(self.wr.write_str("["));
+        let mut first = true;
+        for elt in iter {
+            if first {
+                first = false;
+            } else {
+                try!(self.wr.write_str(","));
+            }
+            try!(elt.serialize(self));
+
+        }
+        self.wr.write_str("]")
+    }
+
+    #[inline]
+    fn serialize_map<
+        K: Serialize<Serializer<W>, IoError>,
+        V: Serialize<Serializer<W>, IoError>,
+        Iter: Iterator<(K, V)>
+    >(&mut self, mut iter: Iter) -> IoResult<()> {
+        try!(self.wr.write_str("{"));
+        let mut first = true;
+        for (key, value) in iter {
+            if first {
+                first = false;
+            } else {
+                try!(self.wr.write_str(","));
+            }
+            try!(key.serialize(self));
+            try!(self.wr.write_str(":"));
+            try!(value.serialize(self));
+        }
+        self.wr.write_str("}")
+    }
+}
+
+/// Another serializer for JSON, but prints out human-readable JSON instead of
+/// compact data
+pub struct PrettySerializer<W> {
+    wr: W,
+    indent: uint,
+    first: bool,
+}
+
+impl<W: Writer> PrettySerializer<W> {
+    /// Creates a new serializer whose output will be written to the specified writer
+    pub fn new(wr: W) -> PrettySerializer<W> {
+        PrettySerializer {
+            wr: wr,
+            indent: 0,
+            first: true,
+        }
+    }
+
+    /// Unwrap the Writer from the Serializer.
+    pub fn unwrap(self) -> W {
+        self.wr
+    }
+
+    #[inline]
+    fn serialize_sep(&mut self) -> IoResult<()> {
+        if self.first {
+            self.first = false;
+            self.indent += 2;
+            try!(self.wr.write_str("\n"));
+        } else {
+            try!(self.wr.write_str(",\n"));
+        }
+
+        spaces(&mut self.wr, self.indent)
+    }
+
+    #[inline]
+    fn serialize_end(&mut self, s: &str) -> IoResult<()> {
+        if !self.first {
+            try!(self.wr.write_str("\n"));
+            self.indent -= 2;
+            try!(spaces(&mut self.wr, self.indent));
+        }
+
+        self.first = false;
+
+        self.wr.write_str(s)
+    }
+}
+
+impl<W: Writer> ser::Serializer<IoError> for PrettySerializer<W> {
+    #[inline]
+    fn serialize_null(&mut self) -> IoResult<()> {
+        self.wr.write_str("null")
+    }
+
+    #[inline]
+    fn serialize_bool(&mut self, v: bool) -> IoResult<()> {
+        if v {
+            self.wr.write_str("true")
+        } else {
+            self.wr.write_str("false")
+        }
+    }
+
+    #[inline]
+    fn serialize_int(&mut self, v: int) -> IoResult<()> {
+        write!(self.wr, "{}", v)
+    }
+
+    #[inline]
+    fn serialize_i8(&mut self, v: i8) -> IoResult<()> {
+        write!(self.wr, "{}", v)
+    }
+
+    #[inline]
+    fn serialize_i16(&mut self, v: i16) -> IoResult<()> {
+        write!(self.wr, "{}", v)
+    }
+
+    #[inline]
+    fn serialize_i32(&mut self, v: i32) -> IoResult<()> {
+        write!(self.wr, "{}", v)
+    }
+
+    #[inline]
+    fn serialize_i64(&mut self, v: i64) -> IoResult<()> {
+        write!(self.wr, "{}", v)
+    }
+
+    #[inline]
+    fn serialize_uint(&mut self, v: uint) -> IoResult<()> {
+        write!(self.wr, "{}", v)
+    }
+
+    #[inline]
+    fn serialize_u8(&mut self, v: u8) -> IoResult<()> {
+        write!(self.wr, "{}", v)
+    }
+
+    #[inline]
+    fn serialize_u16(&mut self, v: u16) -> IoResult<()> {
+        write!(self.wr, "{}", v)
+    }
+
+    #[inline]
+    fn serialize_u32(&mut self, v: u32) -> IoResult<()> {
+        write!(self.wr, "{}", v)
+    }
+
+    #[inline]
+    fn serialize_u64(&mut self, v: u64) -> IoResult<()> {
+        write!(self.wr, "{}", v)
+    }
+
+    #[inline]
+    fn serialize_f32(&mut self, v: f32) -> IoResult<()> {
+        fmt_f32_or_null(&mut self.wr, v)
+    }
+
+    #[inline]
+    fn serialize_f64(&mut self, v: f64) -> IoResult<()> {
+        fmt_f64_or_null(&mut self.wr, v)
+    }
+
+    #[inline]
+    fn serialize_char(&mut self, v: char) -> IoResult<()> {
+        escape_char(&mut self.wr, v)
+    }
+
+    #[inline]
+    fn serialize_str(&mut self, v: &str) -> IoResult<()> {
+        escape_str(&mut self.wr, v)
+    }
+
+    #[inline]
+    fn serialize_tuple_start(&mut self, _len: uint) -> IoResult<()> {
+        self.first = true;
+        self.wr.write_str("[")
+    }
+
+    #[inline]
+    fn serialize_tuple_elt<
+        T: Serialize<PrettySerializer<W>, IoError>
+    >(&mut self, value: &T) -> IoResult<()> {
+        try!(self.serialize_sep());
+        value.serialize(self)
+    }
+
+    #[inline]
+    fn serialize_tuple_end(&mut self) -> IoResult<()> {
+        self.serialize_end("]")
+    }
+
+    #[inline]
+    fn serialize_struct_start(&mut self, _name: &str, _len: uint) -> IoResult<()> {
+        self.first = true;
+        self.wr.write_str("{")
+    }
+
+    #[inline]
+    fn serialize_struct_elt<
+        T: Serialize<PrettySerializer<W>, IoError>
+    >(&mut self, name: &str, value: &T) -> IoResult<()> {
+        try!(self.serialize_sep());
+        try!(self.serialize_str(name));
+        try!(self.wr.write_str(": "));
+        value.serialize(self)
+    }
+
+    #[inline]
+    fn serialize_struct_end(&mut self) -> IoResult<()> {
+        self.serialize_end("}")
+    }
+
+    #[inline]
+    fn serialize_enum_start(&mut self, _name: &str, variant: &str, _len: uint) -> IoResult<()> {
+        self.first = true;
+        try!(self.wr.write_str("{"));
+        try!(self.serialize_sep());
+        try!(self.serialize_str(variant));
+        self.first = true;
+        self.wr.write_str(": [")
+    }
+
+    #[inline]
+    fn serialize_enum_elt<
+        T: Serialize<PrettySerializer<W>, IoError>
+    >(&mut self, value: &T) -> IoResult<()> {
+        try!(self.serialize_sep());
+        value.serialize(self)
+    }
+
+    #[inline]
+    fn serialize_enum_end(&mut self) -> IoResult<()> {
+        try!(self.serialize_tuple_end());
+        self.serialize_struct_end()
+    }
+
+    #[inline]
+    fn serialize_option<
+        T: Serialize<PrettySerializer<W>, IoError>
+    >(&mut self, v: &Option<T>) -> IoResult<()> {
+        match *v {
+            Some(ref v) => {
+                v.serialize(self)
+            }
+            None => {
+                self.serialize_null()
+            }
+        }
+    }
+
+    #[inline]
+    fn serialize_seq<
+        T: Serialize<PrettySerializer<W>, IoError>,
+        Iter: Iterator<T>
+    >(&mut self, mut iter: Iter) -> IoResult<()> {
+        try!(self.wr.write_str("["));
+
+        self.first = true;
+        for elt in iter {
+            try!(self.serialize_sep());
+            try!(elt.serialize(self));
+        }
+
+        self.serialize_end("]")
+    }
+
+    #[inline]
+    fn serialize_map<
+        K: Serialize<PrettySerializer<W>, IoError>,
+        V: Serialize<PrettySerializer<W>, IoError>,
+        Iter: Iterator<(K, V)>
+    >(&mut self, mut iter: Iter) -> IoResult<()> {
+        try!(self.wr.write_str("{"));
+
+        self.first = true;
+        for (key, value) in iter {
+            try!(self.serialize_sep());
+            try!(key.serialize(self));
+            try!(self.wr.write_str(": "));
+            try!(value.serialize(self));
+        }
+
+        self.serialize_end("}")
+    }
+}
+
+/// Encode the specified struct into a json `[u8]` writer.
+#[inline]
+pub fn to_writer<
+    W: Writer,
+    T: Serialize<Serializer<W>, IoError>
+>(writer: W, value: &T) -> IoResult<W> {
+    let mut serializer = Serializer::new(writer);
+    try!(value.serialize(&mut serializer));
+    Ok(serializer.unwrap())
+}
+
+/// Encode the specified struct into a json `[u8]` buffer.
+#[inline]
+pub fn to_vec<
+    T: Serialize<Serializer<MemWriter>, IoError>
+>(value: &T) -> Vec<u8> {
+    // We are writing to a Vec, which doesn't fail. So we can ignore
+    // the error.
+    let writer = MemWriter::with_capacity(128);
+    to_writer(writer, value).unwrap().unwrap()
+}
+
+/// Encode the specified struct into a json `String` buffer.
+#[inline]
+pub fn to_string<
+    T: Serialize<Serializer<MemWriter>, IoError>
+>(value: &T) -> Result<String, Vec<u8>> {
+    let buf = to_vec(value);
+    String::from_utf8(buf)
+}
+
+/// Encode the specified struct into a json `[u8]` writer.
+#[inline]
+pub fn to_pretty_writer<
+    W: Writer,
+    T: Serialize<PrettySerializer<W>, IoError>
+>(writer: W, value: &T) -> IoResult<W> {
+    let mut serializer = PrettySerializer::new(writer);
+    try!(value.serialize(&mut serializer));
+    Ok(serializer.unwrap())
+}
+
+/// Encode the specified struct into a json `[u8]` buffer.
+pub fn to_pretty_vec<
+    T: Serialize<PrettySerializer<MemWriter>, IoError>
+>(value: &T) -> Vec<u8> {
+    // We are writing to a Vec, which doesn't fail. So we can ignore
+    // the error.
+    let writer = MemWriter::with_capacity(128);
+    to_pretty_writer(writer, value).unwrap().unwrap()
+}
+
+/// Encode the specified struct into a json `String` buffer.
+pub fn to_pretty_string<
+    T: Serialize<PrettySerializer<MemWriter>, IoError>
+>(value: &T) -> Result<String, Vec<u8>> {
+    let buf = to_pretty_vec(value);
+    String::from_utf8(buf)
+}