pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-06-14 12:51:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename Serialize::visit to Serialize::serialize

Browse Source
This commit is contained in:
Erick Tryzelaar
2015-03-12 07:33:34 -07:00
parent 3f62b6d2bf
commit 9e454a243a
6 changed files with 62 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files
benches/bench_log.rs
+13 -13
View File
@@ -56,7 +56,7 @@ impl rustc_serialize::Decodable for HttpProtocol {
impl ser::Serialize for HttpProtocol { impl ser::Serialize for HttpProtocol {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: ser::Serializer, where S: ser::Serializer,
{ {
serializer.visit_u8(*self as u8) serializer.visit_u8(*self as u8)
@@ -104,7 +104,7 @@ impl rustc_serialize::Decodable for HttpMethod {
impl ser::Serialize for HttpMethod { impl ser::Serialize for HttpMethod {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: ser::Serializer, where S: ser::Serializer,
{ {
serializer.visit_u8(*self as u8) serializer.visit_u8(*self as u8)
@@ -145,7 +145,7 @@ impl rustc_serialize::Decodable for CacheStatus {
impl ser::Serialize for CacheStatus { impl ser::Serialize for CacheStatus {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: ser::Serializer, where S: ser::Serializer,
{ {
serializer.visit_u8(*self as u8) serializer.visit_u8(*self as u8)
@@ -195,7 +195,7 @@ impl rustc_serialize::Decodable for OriginProtocol {
impl ser::Serialize for OriginProtocol { impl ser::Serialize for OriginProtocol {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: ser::Serializer, where S: ser::Serializer,
{ {
serializer.visit_u8(*self as u8) serializer.visit_u8(*self as u8)
@@ -237,7 +237,7 @@ impl rustc_serialize::Decodable for ZonePlan {
impl ser::Serialize for ZonePlan { impl ser::Serialize for ZonePlan {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: ser::Serializer, where S: ser::Serializer,
{ {
serializer.visit_u8(*self as u8) serializer.visit_u8(*self as u8)
@@ -530,7 +530,7 @@ impl rustc_serialize::Decodable for Country {
impl ser::Serialize for Country { impl ser::Serialize for Country {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: ser::Serializer, where S: ser::Serializer,
{ {
serializer.visit_u8(*self as u8) serializer.visit_u8(*self as u8)
@@ -757,7 +757,7 @@ fn test_serializer_vec() {
let log = Log::new(); let log = Log::new();
let wr = Vec::with_capacity(1024); let wr = Vec::with_capacity(1024);
let mut serializer = json::Serializer::new(wr); let mut serializer = json::Serializer::new(wr);
log.visit(&mut serializer).unwrap(); log.serialize(&mut serializer).unwrap();
let json = serializer.into_inner(); let json = serializer.into_inner();
assert_eq!(&json, &JSON_STR.as_bytes()); assert_eq!(&json, &JSON_STR.as_bytes());
@@ -775,7 +775,7 @@ fn bench_serializer_vec(b: &mut Bencher) {
wr.clear(); wr.clear();
let mut serializer = json::Serializer::new(wr.by_ref()); let mut serializer = json::Serializer::new(wr.by_ref());
log.visit(&mut serializer).unwrap(); log.serialize(&mut serializer).unwrap();
let _json = serializer.into_inner(); let _json = serializer.into_inner();
}); });
} }
@@ -793,7 +793,7 @@ fn bench_serializer_slice(b: &mut Bencher) {
let mut wr = &mut buf[..]; let mut wr = &mut buf[..];
let mut serializer = json::Serializer::new(wr.by_ref()); let mut serializer = json::Serializer::new(wr.by_ref());
log.visit(&mut serializer).unwrap(); log.serialize(&mut serializer).unwrap();
let _json = serializer.into_inner(); let _json = serializer.into_inner();
}); });
} }
@@ -806,7 +806,7 @@ fn test_serializer_my_mem_writer0() {
{ {
let mut serializer = json::Serializer::new(wr.by_ref()); let mut serializer = json::Serializer::new(wr.by_ref());
log.visit(&mut serializer).unwrap(); log.serialize(&mut serializer).unwrap();
let _json = serializer.into_inner(); let _json = serializer.into_inner();
} }
@@ -825,7 +825,7 @@ fn bench_serializer_my_mem_writer0(b: &mut Bencher) {
wr.buf.clear(); wr.buf.clear();
let mut serializer = json::Serializer::new(wr.by_ref()); let mut serializer = json::Serializer::new(wr.by_ref());
log.visit(&mut serializer).unwrap(); log.serialize(&mut serializer).unwrap();
let _json = serializer.into_inner(); let _json = serializer.into_inner();
}); });
} }
@@ -838,7 +838,7 @@ fn test_serializer_my_mem_writer1() {
{ {
let mut serializer = json::Serializer::new(wr.by_ref()); let mut serializer = json::Serializer::new(wr.by_ref());
log.visit(&mut serializer).unwrap(); log.serialize(&mut serializer).unwrap();
let _json = serializer.into_inner(); let _json = serializer.into_inner();
} }
@@ -857,7 +857,7 @@ fn bench_serializer_my_mem_writer1(b: &mut Bencher) {
wr.buf.clear(); wr.buf.clear();
let mut serializer = json::Serializer::new(wr.by_ref()); let mut serializer = json::Serializer::new(wr.by_ref());
log.visit(&mut serializer).unwrap(); log.serialize(&mut serializer).unwrap();
let _json = serializer.into_inner(); let _json = serializer.into_inner();
}); });
} }
serde_macros/src/lib.rs
+1 -1
View File
@@ -78,7 +78,7 @@ fn expand_derive_serialize(
associated_types: vec![], associated_types: vec![],
methods: vec![ methods: vec![
MethodDef { MethodDef {
name: "visit", name: "serialize",
generics: LifetimeBounds { generics: LifetimeBounds {
lifetimes: Vec::new(), lifetimes: Vec::new(),
bounds: vec![ bounds: vec![
src/json/ser.rs
+6 -6
View File
@@ -183,7 +183,7 @@ impl<W> ser::Serializer for Serializer<W>
fn visit_some<V>(&mut self, value: V) -> io::Result<()> fn visit_some<V>(&mut self, value: V) -> io::Result<()>
where V: ser::Serialize where V: ser::Serialize
{ {
value.visit(self) value.serialize(self)
} }
#[inline] #[inline]
@@ -236,7 +236,7 @@ impl<W> ser::Serializer for Serializer<W>
{ {
try!(self.serialize_sep(first)); try!(self.serialize_sep(first));
value.visit(self) value.serialize(self)
} }
#[inline] #[inline]
@@ -272,9 +272,9 @@ impl<W> ser::Serializer for Serializer<W>
V: ser::Serialize, V: ser::Serialize,
{ {
try!(self.serialize_sep(first)); try!(self.serialize_sep(first));
try!(key.visit(self)); try!(key.serialize(self));
try!(self.serialize_colon()); try!(self.serialize_colon());
value.visit(self) value.serialize(self)
} }
} }
@@ -356,7 +356,7 @@ pub fn to_writer<W, T>(writer: &mut W, value: &T) -> io::Result<()>
T: ser::Serialize, T: ser::Serialize,
{ {
let mut ser = Serializer::new(writer); let mut ser = Serializer::new(writer);
try!(value.visit(&mut ser)); try!(value.serialize(&mut ser));
Ok(()) Ok(())
} }
@@ -367,7 +367,7 @@ pub fn to_writer_pretty<W, T>(writer: &mut W, value: &T) -> io::Result<()>
T: ser::Serialize, T: ser::Serialize,
{ {
let mut ser = Serializer::new_pretty(writer); let mut ser = Serializer::new_pretty(writer);
try!(value.visit(&mut ser)); try!(value.serialize(&mut ser));
Ok(()) Ok(())
} }
src/json/value.rs
+8 -8
View File
@@ -21,7 +21,7 @@ pub enum Value {
impl ser::Serialize for Value { impl ser::Serialize for Value {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: ser::Serializer, where S: ser::Serializer,
{ {
match *self { match *self {
@@ -30,8 +30,8 @@ impl ser::Serialize for Value {
Value::I64(v) => serializer.visit_i64(v), Value::I64(v) => serializer.visit_i64(v),
Value::F64(v) => serializer.visit_f64(v), Value::F64(v) => serializer.visit_f64(v),
Value::String(ref v) => serializer.visit_str(&v), Value::String(ref v) => serializer.visit_str(&v),
Value::Array(ref v) => v.visit(serializer), Value::Array(ref v) => v.serialize(serializer),
Value::Object(ref v) => v.visit(serializer), Value::Object(ref v) => v.serialize(serializer),
} }
} }
} }
@@ -210,7 +210,7 @@ impl ser::Serializer for Serializer {
fn visit_some<V>(&mut self, value: V) -> Result<(), ()> fn visit_some<V>(&mut self, value: V) -> Result<(), ()>
where V: ser::Serialize, where V: ser::Serialize,
{ {
value.visit(self) value.serialize(self)
} }
#[inline] #[inline]
@@ -278,7 +278,7 @@ impl ser::Serializer for Serializer {
fn visit_seq_elt<T>(&mut self, _first: bool, value: T) -> Result<(), ()> fn visit_seq_elt<T>(&mut self, _first: bool, value: T) -> Result<(), ()>
where T: ser::Serialize, where T: ser::Serialize,
{ {
try!(value.visit(self)); try!(value.serialize(self));
let value = match self.state.pop().unwrap() { let value = match self.state.pop().unwrap() {
State::Value(value) => value, State::Value(value) => value,
@@ -338,14 +338,14 @@ impl ser::Serializer for Serializer {
where K: ser::Serialize, where K: ser::Serialize,
V: ser::Serialize, V: ser::Serialize,
{ {
try!(key.visit(self)); try!(key.serialize(self));
let key = match self.state.pop().unwrap() { let key = match self.state.pop().unwrap() {
State::Value(Value::String(value)) => value, State::Value(Value::String(value)) => value,
state => panic!("expected key, found {:?}", state), state => panic!("expected key, found {:?}", state),
}; };
try!(value.visit(self)); try!(value.serialize(self));
let value = match self.state.pop().unwrap() { let value = match self.state.pop().unwrap() {
State::Value(value) => value, State::Value(value) => value,
@@ -577,7 +577,7 @@ pub fn to_value<T>(value: &T) -> Value
where T: ser::Serialize where T: ser::Serialize
{ {
let mut ser = Serializer::new(); let mut ser = Serializer::new();
value.visit(&mut ser).ok().unwrap(); value.serialize(&mut ser).ok().unwrap();
ser.unwrap() ser.unwrap()
} }
src/ser.rs
+29 -29
View File
@@ -9,7 +9,7 @@ use std::sync::Arc;
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
pub trait Serialize { pub trait Serialize {
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer; where S: Serializer;
} }
@@ -185,7 +185,7 @@ macro_rules! impl_visit {
($ty:ty, $method:ident) => { ($ty:ty, $method:ident) => {
impl Serialize for $ty { impl Serialize for $ty {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer, where S: Serializer,
{ {
serializer.$method(*self) serializer.$method(*self)
@@ -213,7 +213,7 @@ impl_visit!(char, visit_char);
impl<'a> Serialize for &'a str { impl<'a> Serialize for &'a str {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer, where S: Serializer,
{ {
serializer.visit_str(*self) serializer.visit_str(*self)
@@ -222,10 +222,10 @@ impl<'a> Serialize for &'a str {
impl Serialize for String { impl Serialize for String {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer, where S: Serializer,
{ {
(&self[..]).visit(serializer) (&self[..]).serialize(serializer)
} }
} }
@@ -233,7 +233,7 @@ impl Serialize for String {
impl<T> Serialize for Option<T> where T: Serialize { impl<T> Serialize for Option<T> where T: Serialize {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer, where S: Serializer,
{ {
match *self { match *self {
@@ -294,7 +294,7 @@ impl<'a, T> Serialize for &'a [T]
where T: Serialize, where T: Serialize,
{ {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer, where S: Serializer,
{ {
serializer.visit_seq(SeqIteratorVisitor::new(self.iter())) serializer.visit_seq(SeqIteratorVisitor::new(self.iter()))
@@ -303,16 +303,16 @@ impl<'a, T> Serialize for &'a [T]
impl<T> Serialize for Vec<T> where T: Serialize { impl<T> Serialize for Vec<T> where T: Serialize {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer, where S: Serializer,
{ {
(&self[..]).visit(serializer) (&self[..]).serialize(serializer)
} }
} }
impl<T> Serialize for BTreeSet<T> where T: Serialize { impl<T> Serialize for BTreeSet<T> where T: Serialize {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer, where S: Serializer,
{ {
serializer.visit_seq(SeqIteratorVisitor::new(self.iter())) serializer.visit_seq(SeqIteratorVisitor::new(self.iter()))
@@ -324,7 +324,7 @@ impl<T, H> Serialize for HashSet<T, H>
H: HashState, H: HashState,
{ {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer, where S: Serializer,
{ {
serializer.visit_seq(SeqIteratorVisitor::new(self.iter())) serializer.visit_seq(SeqIteratorVisitor::new(self.iter()))
@@ -335,7 +335,7 @@ impl<T, H> Serialize for HashSet<T, H>
impl Serialize for () { impl Serialize for () {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer, where S: Serializer,
{ {
serializer.visit_unit() serializer.visit_unit()
@@ -403,7 +403,7 @@ macro_rules! tuple_impls {
where $($T: Serialize),+ where $($T: Serialize),+
{ {
#[inline] #[inline]
fn visit<S: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error> { fn serialize<S: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error> {
serializer.visit_seq($TupleVisitor::new(self)) serializer.visit_seq($TupleVisitor::new(self))
} }
} }
@@ -569,7 +569,7 @@ impl<K, V> Serialize for BTreeMap<K, V>
V: Serialize, V: Serialize,
{ {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer, where S: Serializer,
{ {
serializer.visit_map(MapIteratorVisitor::new(self.iter())) serializer.visit_map(MapIteratorVisitor::new(self.iter()))
@@ -582,7 +582,7 @@ impl<K, V, H> Serialize for HashMap<K, V, H>
H: HashState, H: HashState,
{ {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer, where S: Serializer,
{ {
serializer.visit_map(MapIteratorVisitor::new(self.iter())) serializer.visit_map(MapIteratorVisitor::new(self.iter()))
@@ -593,63 +593,63 @@ impl<K, V, H> Serialize for HashMap<K, V, H>
impl<'a, T> Serialize for &'a T where T: Serialize { impl<'a, T> Serialize for &'a T where T: Serialize {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer, where S: Serializer,
{ {
(**self).visit(serializer) (**self).serialize(serializer)
} }
} }
impl<'a, T> Serialize for &'a mut T where T: Serialize { impl<'a, T> Serialize for &'a mut T where T: Serialize {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer, where S: Serializer,
{ {
(**self).visit(serializer) (**self).serialize(serializer)
} }
} }
impl<T> Serialize for Box<T> where T: Serialize { impl<T> Serialize for Box<T> where T: Serialize {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer, where S: Serializer,
{ {
(**self).visit(serializer) (**self).serialize(serializer)
} }
} }
impl<T> Serialize for Rc<T> where T: Serialize, { impl<T> Serialize for Rc<T> where T: Serialize, {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer, where S: Serializer,
{ {
(**self).visit(serializer) (**self).serialize(serializer)
} }
} }
impl<T> Serialize for Arc<T> where T: Serialize, { impl<T> Serialize for Arc<T> where T: Serialize, {
#[inline] #[inline]
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer, where S: Serializer,
{ {
(**self).visit(serializer) (**self).serialize(serializer)
} }
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
impl Serialize for path::Path { impl Serialize for path::Path {
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer, where S: Serializer,
{ {
self.to_str().unwrap().visit(serializer) self.to_str().unwrap().serialize(serializer)
} }
} }
impl Serialize for path::PathBuf { impl Serialize for path::PathBuf {
fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer, where S: Serializer,
{ {
self.to_str().unwrap().visit(serializer) self.to_str().unwrap().serialize(serializer)
} }
} }
tests/test_ser.rs
+5 -5
View File
@@ -180,7 +180,7 @@ impl<'a> Serializer for AssertSerializer<'a> {
where V: Serialize, where V: Serialize,
{ {
assert_eq!(self.iter.next(), Some(Token::Option(true))); assert_eq!(self.iter.next(), Some(Token::Option(true)));
value.visit(self) value.serialize(self)
} }
@@ -221,7 +221,7 @@ impl<'a> Serializer for AssertSerializer<'a> {
where T: Serialize where T: Serialize
{ {
assert_eq!(self.iter.next(), Some(Token::SeqSep(first))); assert_eq!(self.iter.next(), Some(Token::SeqSep(first)));
value.visit(self) value.serialize(self)
} }
fn visit_map<V>(&mut self, visitor: V) -> Result<(), ()> fn visit_map<V>(&mut self, visitor: V) -> Result<(), ()>
@@ -266,8 +266,8 @@ impl<'a> Serializer for AssertSerializer<'a> {
{ {
assert_eq!(self.iter.next(), Some(Token::MapSep(first))); assert_eq!(self.iter.next(), Some(Token::MapSep(first)));
try!(key.visit(self)); try!(key.serialize(self));
value.visit(self) value.serialize(self)
} }
} }
@@ -314,7 +314,7 @@ macro_rules! declare_test {
fn $name() { fn $name() {
$( $(
let mut ser = AssertSerializer::new($tokens); let mut ser = AssertSerializer::new($tokens);
assert_eq!($value.visit(&mut ser), Ok(())); assert_eq!($value.serialize(&mut ser), Ok(()));
)+ )+
} }
} }