use std::io;
use std::num::FpCategory;
use serde::ser;
use super::error::{Error, ErrorCode, Result};
use itoa;
use dtoa;
pub struct Serializer<W, F = CompactFormatter> {
writer: W,
formatter: F,
}
impl<W> Serializer<W>
where W: io::Write,
{
#[inline]
pub fn new(writer: W) -> Self {
Serializer::with_formatter(writer, CompactFormatter)
}
}
impl<'a, W> Serializer<W, PrettyFormatter<'a>>
where W: io::Write,
{
#[inline]
pub fn pretty(writer: W) -> Self {
Serializer::with_formatter(writer, PrettyFormatter::new())
}
}
impl<W, F> Serializer<W, F>
where W: io::Write,
F: Formatter,
{
#[inline]
pub fn with_formatter(writer: W, formatter: F) -> Self {
Serializer {
writer: writer,
formatter: formatter,
}
}
#[inline]
pub fn into_inner(self) -> W {
self.writer
}
}
impl<'a, W, F> ser::Serializer for &'a mut Serializer<W, F>
where W: io::Write,
F: Formatter,
{
type Ok = ();
type Error = Error;
type SerializeSeq = Compound<'a, W, F>;
type SerializeTuple = Compound<'a, W, F>;
type SerializeTupleStruct = Compound<'a, W, F>;
type SerializeTupleVariant = Compound<'a, W, F>;
type SerializeMap = Compound<'a, W, F>;
type SerializeStruct = Compound<'a, W, F>;
type SerializeStructVariant = Compound<'a, W, F>;
#[inline]
fn serialize_bool(self, value: bool) -> Result<()> {
self.formatter.write_bool(&mut self.writer, value)
}
#[inline]
fn serialize_i8(self, value: i8) -> Result<()> {
self.formatter.write_i8(&mut self.writer, value)
}
#[inline]
fn serialize_i16(self, value: i16) -> Result<()> {
self.formatter.write_i16(&mut self.writer, value)
}
#[inline]
fn serialize_i32(self, value: i32) -> Result<()> {
self.formatter.write_i32(&mut self.writer, value)
}
#[inline]
fn serialize_i64(self, value: i64) -> Result<()> {
self.formatter.write_i64(&mut self.writer, value)
}
#[inline]
fn serialize_u8(self, value: u8) -> Result<()> {
self.formatter.write_u8(&mut self.writer, value)
}
#[inline]
fn serialize_u16(self, value: u16) -> Result<()> {
self.formatter.write_u16(&mut self.writer, value)
}
#[inline]
fn serialize_u32(self, value: u32) -> Result<()> {
self.formatter.write_u32(&mut self.writer, value)
}
#[inline]
fn serialize_u64(self, value: u64) -> Result<()> {
self.formatter.write_u64(&mut self.writer, value)
}
#[inline]
fn serialize_f32(self, value: f32) -> Result<()> {
match value.classify() {
FpCategory::Nan | FpCategory::Infinite => {
self.formatter.write_null(&mut self.writer)
}
_ => {
self.formatter.write_f32(&mut self.writer, value)
}
}
}
#[inline]
fn serialize_f64(self, value: f64) -> Result<()> {
match value.classify() {
FpCategory::Nan | FpCategory::Infinite => {
self.formatter.write_null(&mut self.writer)
}
_ => {
self.formatter.write_f64(&mut self.writer, value)
}
}
}
#[inline]
fn serialize_char(self, value: char) -> Result<()> {
format_escaped_char(&mut self.writer, &mut self.formatter, value).map_err(From::from)
}
#[inline]
fn serialize_str(self, value: &str) -> Result<()> {
format_escaped_str(&mut self.writer, &mut self.formatter, value).map_err(From::from)
}
#[inline]
fn serialize_bytes(self, value: &[u8]) -> Result<()> {
use serde::ser::SerializeSeq;
let mut seq = try!(self.serialize_seq(Some(value.len())));
for byte in value {
try!(seq.serialize_element(byte));
}
seq.end()
}
#[inline]
fn serialize_unit(self) -> Result<()> {
self.formatter.write_null(&mut self.writer)
}
#[inline]
fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
self.serialize_unit()
}
#[inline]
fn serialize_unit_variant(
self,
_name: &'static str,
_variant_index: usize,
variant: &'static str
) -> Result<()> {
self.serialize_str(variant)
}
#[inline]
fn serialize_newtype_struct<T: ?Sized>(
self,
_name: &'static str,
value: &T
) -> Result<()>
where T: ser::Serialize,
{
value.serialize(self)
}
#[inline]
fn serialize_newtype_variant<T: ?Sized>(
self,
_name: &'static str,
_variant_index: usize,
variant: &'static str,
value: &T
) -> Result<()>
where T: ser::Serialize,
{
try!(self.formatter.begin_object(&mut self.writer));
try!(self.formatter.begin_object_key(&mut self.writer, true));
try!(self.serialize_str(variant));
try!(self.formatter.end_object_key(&mut self.writer));
try!(self.formatter.begin_object_value(&mut self.writer));
try!(value.serialize(&mut *self));
try!(self.formatter.end_object_value(&mut self.writer));
self.formatter.end_object(&mut self.writer)
}
#[inline]
fn serialize_none(self) -> Result<()> {
self.serialize_unit()
}
#[inline]
fn serialize_some<T: ?Sized>(self, value: &T) -> Result<()>
where T: ser::Serialize,
{
value.serialize(self)
}
#[inline]
fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
if len == Some(0) {
try!(self.formatter.begin_array(&mut self.writer));
try!(self.formatter.end_array(&mut self.writer));
Ok(Compound { ser: self, state: State::Empty })
} else {
try!(self.formatter.begin_array(&mut self.writer));
Ok(Compound { ser: self, state: State::First })
}
}
#[inline]
fn serialize_seq_fixed_size(self, size: usize) -> Result<Self::SerializeSeq> {
self.serialize_seq(Some(size))
}
#[inline]
fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
self.serialize_seq(Some(len))
}
#[inline]
fn serialize_tuple_struct(
self,
_name: &'static str,
len: usize
) -> Result<Self::SerializeTupleStruct> {
self.serialize_seq(Some(len))
}
#[inline]
fn serialize_tuple_variant(
self,
_name: &'static str,
_variant_index: usize,
variant: &'static str,
len: usize
) -> Result<Self::SerializeTupleVariant> {
try!(self.formatter.begin_object(&mut self.writer));
try!(self.formatter.begin_object_key(&mut self.writer, true));
try!(self.serialize_str(variant));
try!(self.formatter.end_object_key(&mut self.writer));
try!(self.formatter.begin_object_value(&mut self.writer));
self.serialize_seq(Some(len))
}
#[inline]
fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
if len == Some(0) {
try!(self.formatter.begin_object(&mut self.writer));
try!(self.formatter.end_object(&mut self.writer));
Ok(Compound { ser: self, state: State::Empty })
} else {
try!(self.formatter.begin_object(&mut self.writer));
Ok(Compound { ser: self, state: State::First })
}
}
#[inline]
fn serialize_struct(
self,
_name: &'static str,
len: usize
) -> Result<Self::SerializeStruct> {
self.serialize_map(Some(len))
}
#[inline]
fn serialize_struct_variant(
self,
_name: &'static str,
_variant_index: usize,
variant: &'static str,
len: usize
) -> Result<Self::SerializeStructVariant> {
try!(self.formatter.begin_object(&mut self.writer));
try!(self.formatter.begin_object_key(&mut self.writer, true));
try!(self.serialize_str(variant));
try!(self.formatter.end_object_key(&mut self.writer));
try!(self.formatter.begin_object_value(&mut self.writer));
self.serialize_map(Some(len))
}
}
#[doc(hidden)]
#[derive(Eq, PartialEq)]
pub enum State {
Empty,
First,
Rest,
}
#[doc(hidden)]
pub struct Compound<'a, W: 'a, F: 'a> {
ser: &'a mut Serializer<W, F>,
state: State,
}
impl<'a, W, F> ser::SerializeSeq for Compound<'a, W, F>
where W: io::Write,
F: Formatter
{
type Ok = ();
type Error = Error;
#[inline]
fn serialize_element<T: ?Sized>(
&mut self,
value: &T
) -> Result<()>
where T: ser::Serialize,
{
try!(self.ser.formatter.begin_array_value(&mut self.ser.writer, self.state == State::First));
self.state = State::Rest;
try!(value.serialize(&mut *self.ser));
self.ser.formatter.end_array_value(&mut self.ser.writer)
}
#[inline]
fn end(self) -> Result<()> {
match self.state {
State::Empty => Ok(()),
_ => self.ser.formatter.end_array(&mut self.ser.writer),
}
}
}
impl<'a, W, F> ser::SerializeTuple for Compound<'a, W, F>
where W: io::Write,
F: Formatter
{
type Ok = ();
type Error = Error;
#[inline]
fn serialize_element<T: ?Sized>(
&mut self,
value: &T,
) -> Result<()>
where T: ser::Serialize,
{
ser::SerializeSeq::serialize_element(self, value)
}
#[inline]
fn end(self) -> Result<()> {
ser::SerializeSeq::end(self)
}
}
impl<'a, W, F> ser::SerializeTupleStruct for Compound<'a, W, F>
where W: io::Write,
F: Formatter
{
type Ok = ();
type Error = Error;
#[inline]
fn serialize_field<T: ?Sized>(
&mut self,
value: &T
) -> Result<()>
where T: ser::Serialize,
{
ser::SerializeSeq::serialize_element(self, value)
}
#[inline]
fn end(self) -> Result<()> {
ser::SerializeSeq::end(self)
}
}
impl<'a, W, F> ser::SerializeTupleVariant for Compound<'a, W, F>
where W: io::Write,
F: Formatter
{
type Ok = ();
type Error = Error;
#[inline]
fn serialize_field<T: ?Sized>(
&mut self,
value: &T
) -> Result<()>
where T: ser::Serialize,
{
ser::SerializeSeq::serialize_element(self, value)
}
#[inline]
fn end(self) -> Result<()> {
match self.state {
State::Empty => {}
_ => try!(self.ser.formatter.end_array(&mut self.ser.writer)),
}
try!(self.ser.formatter.end_object_value(&mut self.ser.writer));
self.ser.formatter.end_object(&mut self.ser.writer)
}
}
impl<'a, W, F> ser::SerializeMap for Compound<'a, W, F>
where W: io::Write,
F: Formatter
{
type Ok = ();
type Error = Error;
#[inline]
fn serialize_key<T: ?Sized>(
&mut self,
key: &T,
) -> Result<()>
where T: ser::Serialize,
{
try!(self.ser.formatter.begin_object_key(&mut self.ser.writer, self.state == State::First));
self.state = State::Rest;
try!(key.serialize(MapKeySerializer {
ser: self.ser,
}));
self.ser.formatter.end_object_key(&mut self.ser.writer)
}
#[inline]
fn serialize_value<T: ?Sized>(
&mut self,
value: &T,
) -> Result<()>
where T: ser::Serialize,
{
try!(self.ser.formatter.begin_object_value(&mut self.ser.writer));
try!(value.serialize(&mut *self.ser));
self.ser.formatter.end_object_value(&mut self.ser.writer)
}
#[inline]
fn end(self) -> Result<()> {
match self.state {
State::Empty => Ok(()),
_ => self.ser.formatter.end_object(&mut self.ser.writer),
}
}
}
impl<'a, W, F> ser::SerializeStruct for Compound<'a, W, F>
where W: io::Write,
F: Formatter
{
type Ok = ();
type Error = Error;
#[inline]
fn serialize_field<T: ?Sized>(
&mut self,
key: &'static str,
value: &T
) -> Result<()>
where T: ser::Serialize,
{
try!(ser::SerializeMap::serialize_key(self, key));
ser::SerializeMap::serialize_value(self, value)
}
#[inline]
fn end(self) -> Result<()> {
ser::SerializeMap::end(self)
}
}
impl<'a, W, F> ser::SerializeStructVariant for Compound<'a, W, F>
where W: io::Write,
F: Formatter
{
type Ok = ();
type Error = Error;
#[inline]
fn serialize_field<T: ?Sized>(
&mut self,
key: &'static str,
value: &T
) -> Result<()>
where T: ser::Serialize,
{
ser::SerializeStruct::serialize_field(self, key, value)
}
#[inline]
fn end(self) -> Result<()> {
match self.state {
State::Empty => {}
_ => try!(self.ser.formatter.end_object(&mut self.ser.writer)),
}
try!(self.ser.formatter.end_object_value(&mut self.ser.writer));
self.ser.formatter.end_object(&mut self.ser.writer)
}
}
struct MapKeySerializer<'a, W: 'a, F: 'a> {
ser: &'a mut Serializer<W, F>,
}
fn key_must_be_a_string() -> Error {
Error::syntax(ErrorCode::KeyMustBeAString, 0, 0)
}
#[doc(hidden)]
pub enum Impossible {}
impl<'a, W, F> ser::Serializer for MapKeySerializer<'a, W, F>
where W: io::Write,
F: Formatter,
{
type Ok = ();
type Error = Error;
#[inline]
fn serialize_str(self, value: &str) -> Result<()> {
self.ser.serialize_str(value)
}
#[inline]
fn serialize_unit_variant(
self,
_name: &'static str,
_variant_index: usize,
variant: &'static str
) -> Result<()> {
self.ser.serialize_str(variant)
}
#[inline]
fn serialize_newtype_struct<T: ?Sized>(
self,
_name: &'static str,
value: &T
) -> Result<()>
where T: ser::Serialize,
{
value.serialize(self)
}
type SerializeSeq = Impossible;
type SerializeTuple = Impossible;
type SerializeTupleStruct = Impossible;
type SerializeTupleVariant = Impossible;
type SerializeMap = Impossible;
type SerializeStruct = Impossible;
type SerializeStructVariant = Impossible;
fn serialize_bool(self, _value: bool) -> Result<()> {
Err(key_must_be_a_string())
}
fn serialize_i8(self, value: i8) -> Result<()> {
try!(self.ser.formatter.begin_string(&mut self.ser.writer));
try!(self.ser.formatter.write_i8(&mut self.ser.writer, value));
self.ser.formatter.end_string(&mut self.ser.writer)
}
fn serialize_i16(self, value: i16) -> Result<()> {
try!(self.ser.formatter.begin_string(&mut self.ser.writer));
try!(self.ser.formatter.write_i16(&mut self.ser.writer, value));
self.ser.formatter.end_string(&mut self.ser.writer)
}
fn serialize_i32(self, value: i32) -> Result<()> {
try!(self.ser.formatter.begin_string(&mut self.ser.writer));
try!(self.ser.formatter.write_i32(&mut self.ser.writer, value));
self.ser.formatter.end_string(&mut self.ser.writer)
}
fn serialize_i64(self, value: i64) -> Result<()> {
try!(self.ser.formatter.begin_string(&mut self.ser.writer));
try!(self.ser.formatter.write_i64(&mut self.ser.writer, value));
self.ser.formatter.end_string(&mut self.ser.writer)
}
fn serialize_u8(self, value: u8) -> Result<()> {
try!(self.ser.formatter.begin_string(&mut self.ser.writer));
try!(self.ser.formatter.write_u8(&mut self.ser.writer, value));
self.ser.formatter.end_string(&mut self.ser.writer)
}
fn serialize_u16(self, value: u16) -> Result<()> {
try!(self.ser.formatter.begin_string(&mut self.ser.writer));
try!(self.ser.formatter.write_u16(&mut self.ser.writer, value));
self.ser.formatter.end_string(&mut self.ser.writer)
}
fn serialize_u32(self, value: u32) -> Result<()> {
try!(self.ser.formatter.begin_string(&mut self.ser.writer));
try!(self.ser.formatter.write_u32(&mut self.ser.writer, value));
self.ser.formatter.end_string(&mut self.ser.writer)
}
fn serialize_u64(self, value: u64) -> Result<()> {
try!(self.ser.formatter.begin_string(&mut self.ser.writer));
try!(self.ser.formatter.write_u64(&mut self.ser.writer, value));
self.ser.formatter.end_string(&mut self.ser.writer)
}
fn serialize_f32(self, _value: f32) -> Result<()> {
Err(key_must_be_a_string())
}
fn serialize_f64(self, _value: f64) -> Result<()> {
Err(key_must_be_a_string())
}
fn serialize_char(self, _value: char) -> Result<()> {
Err(key_must_be_a_string())
}
fn serialize_bytes(self, _value: &[u8]) -> Result<()> {
Err(key_must_be_a_string())
}
fn serialize_unit(self) -> Result<()> {
Err(key_must_be_a_string())
}
fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
Err(key_must_be_a_string())
}
fn serialize_newtype_variant<T: ?Sized>(
self,
_name: &'static str,
_variant_index: usize,
_variant: &'static str,
_value: &T
) -> Result<()>
where T: ser::Serialize,
{
Err(key_must_be_a_string())
}
fn serialize_none(self) -> Result<()> {
Err(key_must_be_a_string())
}
fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<()>
where T: ser::Serialize,
{
Err(key_must_be_a_string())
}
fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
Err(key_must_be_a_string())
}
fn serialize_seq_fixed_size(self, _size: usize) -> Result<Self::SerializeSeq> {
Err(key_must_be_a_string())
}
fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
Err(key_must_be_a_string())
}
fn serialize_tuple_struct(
self,
_name: &'static str,
_len: usize
) -> Result<Self::SerializeTupleStruct> {
Err(key_must_be_a_string())
}
fn serialize_tuple_variant(
self,
_name: &'static str,
_variant_index: usize,
_variant: &'static str,
_len: usize
) -> Result<Self::SerializeTupleVariant> {
Err(key_must_be_a_string())
}
fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
Err(key_must_be_a_string())
}
fn serialize_struct(
self,
_name: &'static str,
_len: usize
) -> Result<Self::SerializeStruct> {
Err(key_must_be_a_string())
}
fn serialize_struct_variant(
self,
_name: &'static str,
_variant_index: usize,
_variant: &'static str,
_len: usize
) -> Result<Self::SerializeStructVariant> {
Err(key_must_be_a_string())
}
}
impl ser::SerializeSeq for Impossible {
type Ok = ();
type Error = Error;
fn serialize_element<T: ?Sized>(&mut self, _: &T) -> Result<()>
where T: ser::Serialize
{
Err(key_must_be_a_string())
}
fn end(self) -> Result<()> {
Err(key_must_be_a_string())
}
}
impl ser::SerializeTuple for Impossible {
type Ok = ();
type Error = Error;
fn serialize_element<T: ?Sized>(&mut self, _: &T) -> Result<()>
where T: ser::Serialize
{
Err(key_must_be_a_string())
}
fn end(self) -> Result<()> {
Err(key_must_be_a_string())
}
}
impl ser::SerializeTupleStruct for Impossible {
type Ok = ();
type Error = Error;
fn serialize_field<T: ?Sized>(&mut self, _: &T) -> Result<()>
where T: ser::Serialize
{
Err(key_must_be_a_string())
}
fn end(self) -> Result<()> {
Err(key_must_be_a_string())
}
}
impl ser::SerializeTupleVariant for Impossible {
type Ok = ();
type Error = Error;
fn serialize_field<T: ?Sized>(&mut self, _: &T) -> Result<()>
where T: ser::Serialize
{
Err(key_must_be_a_string())
}
fn end(self) -> Result<()> {
Err(key_must_be_a_string())
}
}
impl ser::SerializeMap for Impossible {
type Ok = ();
type Error = Error;
fn serialize_key<T: ?Sized>(&mut self, _: &T) -> Result<()>
where T: ser::Serialize
{
Err(key_must_be_a_string())
}
fn serialize_value<T: ?Sized>(&mut self, _: &T) -> Result<()>
where T: ser::Serialize
{
Err(key_must_be_a_string())
}
fn end(self) -> Result<()> {
Err(key_must_be_a_string())
}
}
impl ser::SerializeStruct for Impossible {
type Ok = ();
type Error = Error;
fn serialize_field<T: ?Sized>(&mut self, _: &'static str, _: &T) -> Result<()>
where T: ser::Serialize
{
Err(key_must_be_a_string())
}
fn end(self) -> Result<()> {
Err(key_must_be_a_string())
}
}
impl ser::SerializeStructVariant for Impossible {
type Ok = ();
type Error = Error;
fn serialize_field<T: ?Sized>(&mut self, _: &'static str, _: &T) -> Result<()>
where T: ser::Serialize
{
Err(key_must_be_a_string())
}
fn end(self) -> Result<()> {
Err(key_must_be_a_string())
}
}
pub enum CharEscape {
Quote,
ReverseSolidus,
Solidus,
Backspace,
FormFeed,
LineFeed,
CarriageReturn,
Tab,
AsciiControl(u8),
}
impl CharEscape {
#[inline]
fn from_escape_table(escape: u8, byte: u8) -> CharEscape {
match escape {
self::BB => CharEscape::Backspace,
self::TT => CharEscape::Tab,
self::NN => CharEscape::LineFeed,
self::FF => CharEscape::FormFeed,
self::RR => CharEscape::CarriageReturn,
self::QU => CharEscape::Quote,
self::BS => CharEscape::ReverseSolidus,
self::U => CharEscape::AsciiControl(byte),
_ => unreachable!(),
}
}
}
pub trait Formatter {
#[inline]
fn write_null<W: ?Sized>(&mut self, writer: &mut W) -> Result<()>
where W: io::Write
{
writer.write_all(b"null").map_err(From::from)
}
#[inline]
fn write_bool<W: ?Sized>(&mut self, writer: &mut W, value: bool) -> Result<()>
where W: io::Write
{
let s = if value {
b"true" as &[u8]
} else {
b"false" as &[u8]
};
writer.write_all(s).map_err(From::from)
}
#[inline]
fn write_i8<W: ?Sized>(&mut self, writer: &mut W, value: i8) -> Result<()>
where W: io::Write
{
itoa::write(writer, value).map_err(From::from)
}
#[inline]
fn write_i16<W: ?Sized>(&mut self, writer: &mut W, value: i16) -> Result<()>
where W: io::Write
{
itoa::write(writer, value).map_err(From::from)
}
#[inline]
fn write_i32<W: ?Sized>(&mut self, writer: &mut W, value: i32) -> Result<()>
where W: io::Write
{
itoa::write(writer, value).map_err(From::from)
}
#[inline]
fn write_i64<W: ?Sized>(&mut self, writer: &mut W, value: i64) -> Result<()>
where W: io::Write
{
itoa::write(writer, value).map_err(From::from)
}
#[inline]
fn write_u8<W: ?Sized>(&mut self, writer: &mut W, value: u8) -> Result<()>
where W: io::Write
{
itoa::write(writer, value).map_err(From::from)
}
#[inline]
fn write_u16<W: ?Sized>(&mut self, writer: &mut W, value: u16) -> Result<()>
where W: io::Write
{
itoa::write(writer, value).map_err(From::from)
}
#[inline]
fn write_u32<W: ?Sized>(&mut self, writer: &mut W, value: u32) -> Result<()>
where W: io::Write
{
itoa::write(writer, value).map_err(From::from)
}
#[inline]
fn write_u64<W: ?Sized>(&mut self, writer: &mut W, value: u64) -> Result<()>
where W: io::Write
{
itoa::write(writer, value).map_err(From::from)
}
#[inline]
fn write_f32<W: ?Sized>(&mut self, writer: &mut W, value: f32) -> Result<()>
where W: io::Write
{
dtoa::write(writer, value).map_err(From::from)
}
#[inline]
fn write_f64<W: ?Sized>(&mut self, writer: &mut W, value: f64) -> Result<()>
where W: io::Write
{
dtoa::write(writer, value).map_err(From::from)
}
#[inline]
fn begin_string<W: ?Sized>(&mut self, writer: &mut W) -> Result<()>
where W: io::Write
{
writer.write_all(b"\"").map_err(From::from)
}
#[inline]
fn end_string<W: ?Sized>(&mut self, writer: &mut W) -> Result<()>
where W: io::Write
{
writer.write_all(b"\"").map_err(From::from)
}
#[inline]
fn write_string_fragment<W: ?Sized>(&mut self, writer: &mut W, fragment: &[u8]) -> Result<()>
where W: io::Write
{
writer.write_all(fragment).map_err(From::from)
}
#[inline]
fn write_char_escape<W: ?Sized>(&mut self, writer: &mut W, char_escape: CharEscape) -> Result<()>
where W: io::Write
{
use self::CharEscape::*;
let s = match char_escape {
Quote => b"\\\"",
ReverseSolidus => b"\\\\",
Solidus => b"\\/",
Backspace => b"\\b",
FormFeed => b"\\f",
LineFeed => b"\\n",
CarriageReturn => b"\\r",
Tab => b"\\t",
AsciiControl(byte) => {
static HEX_DIGITS: [u8; 16] = *b"0123456789abcdef";
let bytes = &[b'\\', b'u', b'0', b'0',
HEX_DIGITS[(byte >> 4) as usize],
HEX_DIGITS[(byte & 0xF) as usize]];
return writer.write_all(bytes).map_err(From::from);
}
};
writer.write_all(s).map_err(From::from)
}
#[inline]
fn begin_array<W: ?Sized>(&mut self, writer: &mut W) -> Result<()>
where W: io::Write
{
writer.write_all(b"[").map_err(From::from)
}
#[inline]
fn end_array<W: ?Sized>(&mut self, writer: &mut W) -> Result<()>
where W: io::Write
{
writer.write_all(b"]").map_err(From::from)
}
#[inline]
fn begin_array_value<W: ?Sized>(&mut self, writer: &mut W, first: bool) -> Result<()>
where W: io::Write
{
if first {
Ok(())
} else {
writer.write_all(b",").map_err(From::from)
}
}
#[inline]
fn end_array_value<W: ?Sized>(&mut self, _writer: &mut W) -> Result<()>
where W: io::Write
{
Ok(())
}
#[inline]
fn begin_object<W: ?Sized>(&mut self, writer: &mut W) -> Result<()>
where W: io::Write
{
writer.write_all(b"{").map_err(From::from)
}
#[inline]
fn end_object<W: ?Sized>(&mut self, writer: &mut W) -> Result<()>
where W: io::Write
{
writer.write_all(b"}").map_err(From::from)
}
#[inline]
fn begin_object_key<W: ?Sized>(&mut self, writer: &mut W, first: bool) -> Result<()>
where W: io::Write
{
if first {
Ok(())
} else {
writer.write_all(b",").map_err(From::from)
}
}
#[inline]
fn end_object_key<W: ?Sized>(&mut self, _writer: &mut W) -> Result<()>
where W: io::Write
{
Ok(())
}
#[inline]
fn begin_object_value<W: ?Sized>(&mut self, writer: &mut W) -> Result<()>
where W: io::Write
{
writer.write_all(b":").map_err(From::from)
}
#[inline]
fn end_object_value<W: ?Sized>(&mut self, _writer: &mut W) -> Result<()>
where W: io::Write
{
Ok(())
}
}
#[derive(Clone, Debug)]
pub struct CompactFormatter;
impl Formatter for CompactFormatter {}
#[derive(Clone, Debug)]
pub struct PrettyFormatter<'a> {
current_indent: usize,
has_value: bool,
indent: &'a [u8],
}
impl<'a> PrettyFormatter<'a> {
pub fn new() -> Self {
PrettyFormatter::with_indent(b" ")
}
pub fn with_indent(indent: &'a [u8]) -> Self {
PrettyFormatter {
current_indent: 0,
has_value: false,
indent: indent,
}
}
}
impl<'a> Default for PrettyFormatter<'a> {
fn default() -> Self {
PrettyFormatter::new()
}
}
impl<'a> Formatter for PrettyFormatter<'a> {
#[inline]
fn begin_array<W: ?Sized>(&mut self, writer: &mut W) -> Result<()>
where W: io::Write
{
self.current_indent += 1;
self.has_value = false;
writer.write_all(b"[").map_err(From::from)
}
#[inline]
fn end_array<W: ?Sized>(&mut self, writer: &mut W) -> Result<()>
where W: io::Write
{
self.current_indent -= 1;
if self.has_value {
try!(writer.write_all(b"\n"));
try!(indent(writer, self.current_indent, self.indent));
}
writer.write_all(b"]").map_err(From::from)
}
#[inline]
fn begin_array_value<W: ?Sized>(&mut self, writer: &mut W, first: bool) -> Result<()>
where W: io::Write
{
if first {
try!(writer.write_all(b"\n"));
} else {
try!(writer.write_all(b",\n"));
}
try!(indent(writer, self.current_indent, self.indent));
Ok(())
}
#[inline]
fn end_array_value<W: ?Sized>(&mut self, _writer: &mut W) -> Result<()>
where W: io::Write
{
self.has_value = true;
Ok(())
}
#[inline]
fn begin_object<W: ?Sized>(&mut self, writer: &mut W) -> Result<()>
where W: io::Write
{
self.current_indent += 1;
self.has_value = false;
writer.write_all(b"{").map_err(From::from)
}
#[inline]
fn end_object<W: ?Sized>(&mut self, writer: &mut W) -> Result<()>
where W: io::Write
{
self.current_indent -= 1;
if self.has_value {
try!(writer.write_all(b"\n"));
try!(indent(writer, self.current_indent, self.indent));
}
writer.write_all(b"}").map_err(From::from)
}
#[inline]
fn begin_object_key<W: ?Sized>(&mut self, writer: &mut W, first: bool) -> Result<()>
where W: io::Write
{
if first {
try!(writer.write_all(b"\n"));
} else {
try!(writer.write_all(b",\n"));
}
indent(writer, self.current_indent, self.indent)
}
#[inline]
fn begin_object_value<W: ?Sized>(&mut self, writer: &mut W) -> Result<()>
where W: io::Write
{
writer.write_all(b": ").map_err(From::from)
}
#[inline]
fn end_object_value<W: ?Sized>(&mut self, _writer: &mut W) -> Result<()>
where W: io::Write
{
self.has_value = true;
Ok(())
}
}
fn format_escaped_str<W: ?Sized, F: ?Sized>(writer: &mut W, formatter: &mut F, value: &str) -> Result<()>
where W: io::Write,
F: Formatter
{
let bytes = value.as_bytes();
try!(formatter.begin_string(writer));
let mut start = 0;
for (i, &byte) in bytes.iter().enumerate() {
let escape = ESCAPE[byte as usize];
if escape == 0 {
continue;
}
if start < i {
try!(formatter.write_string_fragment(writer, &bytes[start..i]));
}
let char_escape = CharEscape::from_escape_table(escape, byte);
try!(formatter.write_char_escape(writer, char_escape));
start = i + 1;
}
if start != bytes.len() {
try!(formatter.write_string_fragment(writer, &bytes[start..]));
}
try!(formatter.end_string(writer));
Ok(())
}
const BB: u8 = b'b'; const TT: u8 = b't'; const NN: u8 = b'n'; const FF: u8 = b'f'; const RR: u8 = b'r'; const QU: u8 = b'"'; const BS: u8 = b'\\'; const U: u8 = b'u';
#[cfg_attr(rustfmt, rustfmt_skip)]
static ESCAPE: [u8; 256] = [
U, U, U, U, U, U, U, U, BB, TT, NN, U, FF, RR, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, 0, 0, QU, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, BS, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ];
#[inline]
fn format_escaped_char<W: ?Sized, F: ?Sized>(wr: &mut W, formatter: &mut F, value: char) -> Result<()>
where W: io::Write,
F: Formatter,
{
let mut s = String::new();
s.push(value);
format_escaped_str(wr, formatter, &s)
}
#[inline]
pub fn to_writer<W: ?Sized, T: ?Sized>(writer: &mut W, value: &T) -> Result<()>
where W: io::Write,
T: ser::Serialize,
{
let mut ser = Serializer::new(writer);
try!(value.serialize(&mut ser));
Ok(())
}
#[inline]
pub fn to_writer_pretty<W: ?Sized, T: ?Sized>(writer: &mut W, value: &T) -> Result<()>
where W: io::Write,
T: ser::Serialize,
{
let mut ser = Serializer::pretty(writer);
try!(value.serialize(&mut ser));
Ok(())
}
#[inline]
pub fn to_vec<T: ?Sized>(value: &T) -> Result<Vec<u8>>
where T: ser::Serialize,
{
let mut writer = Vec::with_capacity(128);
try!(to_writer(&mut writer, value));
Ok(writer)
}
#[inline]
pub fn to_vec_pretty<T: ?Sized>(value: &T) -> Result<Vec<u8>>
where T: ser::Serialize,
{
let mut writer = Vec::with_capacity(128);
try!(to_writer_pretty(&mut writer, value));
Ok(writer)
}
#[inline]
pub fn to_string<T: ?Sized>(value: &T) -> Result<String>
where T: ser::Serialize,
{
let vec = try!(to_vec(value));
let string = unsafe {
String::from_utf8_unchecked(vec)
};
Ok(string)
}
#[inline]
pub fn to_string_pretty<T: ?Sized>(value: &T) -> Result<String>
where T: ser::Serialize,
{
let vec = try!(to_vec_pretty(value));
let string = unsafe {
String::from_utf8_unchecked(vec)
};
Ok(string)
}
fn indent<W: ?Sized>(wr: &mut W, n: usize, s: &[u8]) -> Result<()>
where W: io::Write,
{
for _ in 0..n {
try!(wr.write_all(s));
}
Ok(())
}