pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-04-23 05:58:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge ser::Serializer and ser::Visitor

Browse Source
This commit is contained in:
Erick Tryzelaar
2015-03-11 11:05:46 -07:00
parent fbd6d1974a
commit 3f62b6d2bf
6 changed files with 179 additions and 225 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/json/ser.rs
+19 -42
View File
@@ -49,32 +49,7 @@ impl<W: io::Write> Serializer<W> {
pub fn into_inner(self) -> W {
self.writer
}
}
impl<W: io::Write> ser::Serializer for Serializer<W> {
type Error = io::Error;
#[inline]
fn visit<T>(&mut self, value: &T) -> io::Result<()>
where T: ser::Serialize,
{
value.visit(&mut Visitor {
writer: &mut self.writer,
format: self.format,
current_indent: self.current_indent,
indent: self.indent,
})
}
}
struct Visitor<'a, W: 'a> {
writer: &'a mut W,
format: Format,
current_indent: usize,
indent: usize,
}
impl<'a, W> Visitor<'a, W> where W: io::Write, {
fn serialize_sep(&mut self, first: bool) -> io::Result<()> {
match self.format {
Format::Compact => {
@@ -115,7 +90,9 @@ impl<'a, W> Visitor<'a, W> where W: io::Write, {
}
}
impl<'a, W> ser::Visitor for Visitor<'a, W> where W: io::Write, {
impl<W> ser::Serializer for Serializer<W>
where W: io::Write,
{
type Error = io::Error;
#[inline]
@@ -129,72 +106,72 @@ impl<'a, W> ser::Visitor for Visitor<'a, W> where W: io::Write, {
#[inline]
fn visit_isize(&mut self, value: isize) -> io::Result<()> {
write!(self.writer, "{}", value)
write!(&mut self.writer, "{}", value)
}
#[inline]
fn visit_i8(&mut self, value: i8) -> io::Result<()> {
write!(self.writer, "{}", value)
write!(&mut self.writer, "{}", value)
}
#[inline]
fn visit_i16(&mut self, value: i16) -> io::Result<()> {
write!(self.writer, "{}", value)
write!(&mut self.writer, "{}", value)
}
#[inline]
fn visit_i32(&mut self, value: i32) -> io::Result<()> {
write!(self.writer, "{}", value)
write!(&mut self.writer, "{}", value)
}
#[inline]
fn visit_i64(&mut self, value: i64) -> io::Result<()> {
write!(self.writer, "{}", value)
write!(&mut self.writer, "{}", value)
}
#[inline]
fn visit_usize(&mut self, value: usize) -> io::Result<()> {
write!(self.writer, "{}", value)
write!(&mut self.writer, "{}", value)
}
#[inline]
fn visit_u8(&mut self, value: u8) -> io::Result<()> {
write!(self.writer, "{}", value)
write!(&mut self.writer, "{}", value)
}
#[inline]
fn visit_u16(&mut self, value: u16) -> io::Result<()> {
write!(self.writer, "{}", value)
write!(&mut self.writer, "{}", value)
}
#[inline]
fn visit_u32(&mut self, value: u32) -> io::Result<()> {
write!(self.writer, "{}", value)
write!(&mut self.writer, "{}", value)
}
#[inline]
fn visit_u64(&mut self, value: u64) -> io::Result<()> {
write!(self.writer, "{}", value)
write!(&mut self.writer, "{}", value)
}
#[inline]
fn visit_f32(&mut self, value: f32) -> io::Result<()> {
fmt_f32_or_null(self.writer, value)
fmt_f32_or_null(&mut self.writer, value)
}
#[inline]
fn visit_f64(&mut self, value: f64) -> io::Result<()> {
fmt_f64_or_null(self.writer, value)
fmt_f64_or_null(&mut self.writer, value)
}
#[inline]
fn visit_char(&mut self, value: char) -> io::Result<()> {
escape_char(self.writer, value)
escape_char(&mut self.writer, value)
}
#[inline]
fn visit_str(&mut self, value: &str) -> io::Result<()> {
escape_str(self.writer, value)
escape_str(&mut self.writer, value)
}
#[inline]
@@ -379,7 +356,7 @@ pub fn to_writer<W, T>(writer: &mut W, value: &T) -> io::Result<()>
T: ser::Serialize,
{
let mut ser = Serializer::new(writer);
try!(ser::Serializer::visit(&mut ser, value));
try!(value.visit(&mut ser));
Ok(())
}
@@ -390,7 +367,7 @@ pub fn to_writer_pretty<W, T>(writer: &mut W, value: &T) -> io::Result<()>
T: ser::Serialize,
{
let mut ser = Serializer::new_pretty(writer);
try!(ser::Serializer::visit(&mut ser, value));
try!(value.visit(&mut ser));
Ok(())
}
src/json/value.rs
+10 -22
View File
@@ -21,17 +21,17 @@ pub enum Value {
impl ser::Serialize for Value {
#[inline]
fn visit<V>(&self, visitor: &mut V) -> Result<(), V::Error>
where V: ser::Visitor,
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: ser::Serializer,
{
match *self {
Value::Null => visitor.visit_unit(),
Value::Bool(v) => visitor.visit_bool(v),
Value::I64(v) => visitor.visit_i64(v),
Value::F64(v) => visitor.visit_f64(v),
Value::String(ref v) => visitor.visit_str(&v),
Value::Array(ref v) => v.visit(visitor),
Value::Object(ref v) => v.visit(visitor),
Value::Null => serializer.visit_unit(),
Value::Bool(v) => serializer.visit_bool(v),
Value::I64(v) => serializer.visit_i64(v),
Value::F64(v) => serializer.visit_f64(v),
Value::String(ref v) => serializer.visit_str(&v),
Value::Array(ref v) => v.visit(serializer),
Value::Object(ref v) => v.visit(serializer),
}
}
}
@@ -165,18 +165,6 @@ impl Serializer {
impl ser::Serializer for Serializer {
type Error = ();
#[inline]
fn visit<T>(&mut self, value: &T) -> Result<(), ()>
where T: ser::Serialize,
{
try!(value.visit(self));
Ok(())
}
}
impl ser::Visitor for Serializer {
type Error = ();
#[inline]
fn visit_bool(&mut self, value: bool) -> Result<(), ()> {
self.state.push(State::Value(Value::Bool(value)));
@@ -589,7 +577,7 @@ pub fn to_value<T>(value: &T) -> Value
where T: ser::Serialize
{
let mut ser = Serializer::new();
ser::Serializer::visit(&mut ser, value).ok().unwrap();
value.visit(&mut ser).ok().unwrap();
ser.unwrap()
}
src/ser.rs
+79 -82
View File
@@ -9,8 +9,8 @@ use std::sync::Arc;
///////////////////////////////////////////////////////////////////////////////
pub trait Serialize {
fn visit<V>(&self, visitor: &mut V) -> Result<(), V::Error>
where V: Visitor;
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer;
}
///////////////////////////////////////////////////////////////////////////////
@@ -18,15 +18,6 @@ pub trait Serialize {
pub trait Serializer {
type Error;
fn visit<T>(&mut self, value: &T) -> Result<(), Self::Error>
where T: Serialize;
}
///////////////////////////////////////////////////////////////////////////////
pub trait Visitor {
type Error;
fn visit_bool(&mut self, v: bool) -> Result<(), Self::Error>;
#[inline]
@@ -169,8 +160,8 @@ pub trait Visitor {
}
pub trait SeqVisitor {
fn visit<V>(&mut self, visitor: &mut V) -> Result<Option<()>, V::Error>
where V: Visitor;
fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
where S: Serializer;
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
@@ -179,8 +170,8 @@ pub trait SeqVisitor {
}
pub trait MapVisitor {
fn visit<V>(&mut self, visitor: &mut V) -> Result<Option<()>, V::Error>
where V: Visitor;
fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
where S: Serializer;
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
@@ -194,10 +185,10 @@ macro_rules! impl_visit {
($ty:ty, $method:ident) => {
impl Serialize for $ty {
#[inline]
fn visit<V>(&self, visitor: &mut V) -> Result<(), V::Error>
where V: Visitor,
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
visitor.$method(*self)
serializer.$method(*self)
}
}
}
@@ -222,19 +213,19 @@ impl_visit!(char, visit_char);
impl<'a> Serialize for &'a str {
#[inline]
fn visit<V>(&self, visitor: &mut V) -> Result<(), V::Error>
where V: Visitor,
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
visitor.visit_str(*self)
serializer.visit_str(*self)
}
}
impl Serialize for String {
#[inline]
fn visit<V>(&self, visitor: &mut V) -> Result<(), V::Error>
where V: Visitor,
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
(&self[..]).visit(visitor)
(&self[..]).visit(serializer)
}
}
@@ -242,12 +233,12 @@ impl Serialize for String {
impl<T> Serialize for Option<T> where T: Serialize {
#[inline]
fn visit<V>(&self, visitor: &mut V) -> Result<(), V::Error>
where V: Visitor,
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
match *self {
Some(ref value) => visitor.visit_some(value),
None => visitor.visit_none(),
Some(ref value) => serializer.visit_some(value),
None => serializer.visit_none(),
}
}
}
@@ -276,15 +267,15 @@ impl<T, Iter> SeqVisitor for SeqIteratorVisitor<Iter>
Iter: Iterator<Item=T>,
{
#[inline]
fn visit<V>(&mut self, visitor: &mut V) -> Result<Option<()>, V::Error>
where V: Visitor,
fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
where S: Serializer,
{
let first = self.first;
self.first = false;
match self.iter.next() {
Some(value) => {
let value = try!(visitor.visit_seq_elt(first, value));
let value = try!(serializer.visit_seq_elt(first, value));
Ok(Some(value))
}
None => Ok(None),
@@ -303,38 +294,40 @@ impl<'a, T> Serialize for &'a [T]
where T: Serialize,
{
#[inline]
fn visit<V>(&self, visitor: &mut V) -> Result<(), V::Error>
where V: Visitor,
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
visitor.visit_seq(SeqIteratorVisitor::new(self.iter()))
serializer.visit_seq(SeqIteratorVisitor::new(self.iter()))
}
}
impl<T> Serialize for Vec<T> where T: Serialize {
#[inline]
fn visit<V>(&self, visitor: &mut V) -> Result<(), V::Error>
where V: Visitor,
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
(&self[..]).visit(visitor)
(&self[..]).visit(serializer)
}
}
impl<T> Serialize for BTreeSet<T> where T: Serialize {
#[inline]
fn visit<V>(&self, visitor: &mut V) -> Result<(), V::Error>
where V: Visitor,
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
visitor.visit_seq(SeqIteratorVisitor::new(self.iter()))
serializer.visit_seq(SeqIteratorVisitor::new(self.iter()))
}
}
impl<T, S> Serialize for HashSet<T, S>
impl<T, H> Serialize for HashSet<T, H>
where T: Serialize + Eq + Hash,
S: HashState,
H: HashState,
{
#[inline]
fn visit<V: Visitor>(&self, visitor: &mut V) -> Result<(), V::Error> {
visitor.visit_seq(SeqIteratorVisitor::new(self.iter()))
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
serializer.visit_seq(SeqIteratorVisitor::new(self.iter()))
}
}
@@ -342,10 +335,10 @@ impl<T, S> Serialize for HashSet<T, S>
impl Serialize for () {
#[inline]
fn visit<V>(&self, visitor: &mut V) -> Result<(), V::Error>
where V: Visitor,
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
visitor.visit_unit()
serializer.visit_unit()
}
}
@@ -382,8 +375,8 @@ macro_rules! tuple_impls {
impl<'a, $($T),+> SeqVisitor for $TupleVisitor<'a, $($T),+>
where $($T: Serialize),+
{
fn visit<V>(&mut self, visitor: &mut V) -> Result<Option<()>, V::Error>
where V: Visitor,
fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
where S: Serializer,
{
let first = self.first;
self.first = false;
@@ -392,7 +385,7 @@ macro_rules! tuple_impls {
$(
$state => {
self.state += 1;
Ok(Some(try!(visitor.visit_seq_elt(first, &e!(self.tuple.$idx)))))
Ok(Some(try!(serializer.visit_seq_elt(first, &e!(self.tuple.$idx)))))
}
)+
_ => {
@@ -410,8 +403,8 @@ macro_rules! tuple_impls {
where $($T: Serialize),+
{
#[inline]
fn visit<V: Visitor>(&self, visitor: &mut V) -> Result<(), V::Error> {
visitor.visit_seq($TupleVisitor::new(self))
fn visit<S: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error> {
serializer.visit_seq($TupleVisitor::new(self))
}
}
)+
@@ -548,15 +541,15 @@ impl<K, V, I> MapVisitor for MapIteratorVisitor<I>
I: Iterator<Item=(K, V)>,
{
#[inline]
fn visit<V_>(&mut self, visitor: &mut V_) -> Result<Option<()>, V_::Error>
where V_: Visitor,
fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
where S: Serializer,
{
let first = self.first;
self.first = false;
match self.iter.next() {
Some((key, value)) => {
let value = try!(visitor.visit_map_elt(first, key, value));
let value = try!(serializer.visit_map_elt(first, key, value));
Ok(Some(value))
}
None => Ok(None)
@@ -576,19 +569,23 @@ impl<K, V> Serialize for BTreeMap<K, V>
V: Serialize,
{
#[inline]
fn visit<V_: Visitor>(&self, visitor: &mut V_) -> Result<(), V_::Error> {
visitor.visit_map(MapIteratorVisitor::new(self.iter()))
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
serializer.visit_map(MapIteratorVisitor::new(self.iter()))
}
}
impl<K, V, S> Serialize for HashMap<K, V, S>
impl<K, V, H> Serialize for HashMap<K, V, H>
where K: Serialize + Eq + Hash,
V: Serialize,
S: HashState,
H: HashState,
{
#[inline]
fn visit<V_: Visitor>(&self, visitor: &mut V_) -> Result<(), V_::Error> {
visitor.visit_map(MapIteratorVisitor::new(self.iter()))
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
serializer.visit_map(MapIteratorVisitor::new(self.iter()))
}
}
@@ -596,63 +593,63 @@ impl<K, V, S> Serialize for HashMap<K, V, S>
impl<'a, T> Serialize for &'a T where T: Serialize {
#[inline]
fn visit<V>(&self, visitor: &mut V) -> Result<(), V::Error>
where V: Visitor,
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
(**self).visit(visitor)
(**self).visit(serializer)
}
}
impl<'a, T> Serialize for &'a mut T where T: Serialize {
#[inline]
fn visit<V>(&self, visitor: &mut V) -> Result<(), V::Error>
where V: Visitor,
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
(**self).visit(visitor)
(**self).visit(serializer)
}
}
impl<T> Serialize for Box<T> where T: Serialize {
#[inline]
fn visit<V>(&self, visitor: &mut V) -> Result<(), V::Error>
where V: Visitor,
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
(**self).visit(visitor)
(**self).visit(serializer)
}
}
impl<T> Serialize for Rc<T> where T: Serialize, {
#[inline]
fn visit<V>(&self, visitor: &mut V) -> Result<(), V::Error>
where V: Visitor,
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
(**self).visit(visitor)
(**self).visit(serializer)
}
}
impl<T> Serialize for Arc<T> where T: Serialize, {
#[inline]
fn visit<V>(&self, visitor: &mut V) -> Result<(), V::Error>
where V: Visitor,
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
(**self).visit(visitor)
(**self).visit(serializer)
}
}
///////////////////////////////////////////////////////////////////////////////
impl Serialize for path::Path {
fn visit<V>(&self, visitor: &mut V) -> Result<(), V::Error>
where V: Visitor,
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
self.to_str().unwrap().visit(visitor)
self.to_str().unwrap().visit(serializer)
}
}
impl Serialize for path::PathBuf {
fn visit<V>(&self, visitor: &mut V) -> Result<(), V::Error>
where V: Visitor,
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
self.to_str().unwrap().visit(visitor)
self.to_str().unwrap().visit(serializer)
}
}