From 9e454a243a67332bc1af3997a1787ac3acb5c3b1 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Thu, 12 Mar 2015 07:33:34 -0700 Subject: [PATCH] Rename Serialize::visit to Serialize::serialize --- benches/bench_log.rs | 26 +++++++++--------- serde_macros/src/lib.rs | 2 +- src/json/ser.rs | 12 ++++----- src/json/value.rs | 16 ++++++------ src/ser.rs | 58 ++++++++++++++++++++--------------------- tests/test_ser.rs | 10 +++---- 6 files changed, 62 insertions(+), 62 deletions(-) diff --git a/benches/bench_log.rs b/benches/bench_log.rs index 49dca4bb..2593d8df 100644 --- a/benches/bench_log.rs +++ b/benches/bench_log.rs @@ -56,7 +56,7 @@ impl rustc_serialize::Decodable for HttpProtocol { impl ser::Serialize for HttpProtocol { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: ser::Serializer, { serializer.visit_u8(*self as u8) @@ -104,7 +104,7 @@ impl rustc_serialize::Decodable for HttpMethod { impl ser::Serialize for HttpMethod { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: ser::Serializer, { serializer.visit_u8(*self as u8) @@ -145,7 +145,7 @@ impl rustc_serialize::Decodable for CacheStatus { impl ser::Serialize for CacheStatus { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: ser::Serializer, { serializer.visit_u8(*self as u8) @@ -195,7 +195,7 @@ impl rustc_serialize::Decodable for OriginProtocol { impl ser::Serialize for OriginProtocol { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: ser::Serializer, { serializer.visit_u8(*self as u8) @@ -237,7 +237,7 @@ impl rustc_serialize::Decodable for ZonePlan { impl ser::Serialize for ZonePlan { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: ser::Serializer, { serializer.visit_u8(*self as u8) @@ -530,7 +530,7 @@ impl rustc_serialize::Decodable for Country { impl ser::Serialize for Country { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: ser::Serializer, { serializer.visit_u8(*self as u8) @@ -757,7 +757,7 @@ fn test_serializer_vec() { let log = Log::new(); let wr = Vec::with_capacity(1024); let mut serializer = json::Serializer::new(wr); - log.visit(&mut serializer).unwrap(); + log.serialize(&mut serializer).unwrap(); let json = serializer.into_inner(); assert_eq!(&json, &JSON_STR.as_bytes()); @@ -775,7 +775,7 @@ fn bench_serializer_vec(b: &mut Bencher) { wr.clear(); let mut serializer = json::Serializer::new(wr.by_ref()); - log.visit(&mut serializer).unwrap(); + log.serialize(&mut serializer).unwrap(); let _json = serializer.into_inner(); }); } @@ -793,7 +793,7 @@ fn bench_serializer_slice(b: &mut Bencher) { let mut wr = &mut buf[..]; let mut serializer = json::Serializer::new(wr.by_ref()); - log.visit(&mut serializer).unwrap(); + log.serialize(&mut serializer).unwrap(); let _json = serializer.into_inner(); }); } @@ -806,7 +806,7 @@ fn test_serializer_my_mem_writer0() { { let mut serializer = json::Serializer::new(wr.by_ref()); - log.visit(&mut serializer).unwrap(); + log.serialize(&mut serializer).unwrap(); let _json = serializer.into_inner(); } @@ -825,7 +825,7 @@ fn bench_serializer_my_mem_writer0(b: &mut Bencher) { wr.buf.clear(); let mut serializer = json::Serializer::new(wr.by_ref()); - log.visit(&mut serializer).unwrap(); + log.serialize(&mut serializer).unwrap(); let _json = serializer.into_inner(); }); } @@ -838,7 +838,7 @@ fn test_serializer_my_mem_writer1() { { let mut serializer = json::Serializer::new(wr.by_ref()); - log.visit(&mut serializer).unwrap(); + log.serialize(&mut serializer).unwrap(); let _json = serializer.into_inner(); } @@ -857,7 +857,7 @@ fn bench_serializer_my_mem_writer1(b: &mut Bencher) { wr.buf.clear(); let mut serializer = json::Serializer::new(wr.by_ref()); - log.visit(&mut serializer).unwrap(); + log.serialize(&mut serializer).unwrap(); let _json = serializer.into_inner(); }); } diff --git a/serde_macros/src/lib.rs b/serde_macros/src/lib.rs index 68917987..4c6a09a2 100644 --- a/serde_macros/src/lib.rs +++ b/serde_macros/src/lib.rs @@ -78,7 +78,7 @@ fn expand_derive_serialize( associated_types: vec![], methods: vec![ MethodDef { - name: "visit", + name: "serialize", generics: LifetimeBounds { lifetimes: Vec::new(), bounds: vec![ diff --git a/src/json/ser.rs b/src/json/ser.rs index 61b3d177..c6d32309 100644 --- a/src/json/ser.rs +++ b/src/json/ser.rs @@ -183,7 +183,7 @@ impl ser::Serializer for Serializer fn visit_some(&mut self, value: V) -> io::Result<()> where V: ser::Serialize { - value.visit(self) + value.serialize(self) } #[inline] @@ -236,7 +236,7 @@ impl ser::Serializer for Serializer { try!(self.serialize_sep(first)); - value.visit(self) + value.serialize(self) } #[inline] @@ -272,9 +272,9 @@ impl ser::Serializer for Serializer V: ser::Serialize, { try!(self.serialize_sep(first)); - try!(key.visit(self)); + try!(key.serialize(self)); try!(self.serialize_colon()); - value.visit(self) + value.serialize(self) } } @@ -356,7 +356,7 @@ pub fn to_writer(writer: &mut W, value: &T) -> io::Result<()> T: ser::Serialize, { let mut ser = Serializer::new(writer); - try!(value.visit(&mut ser)); + try!(value.serialize(&mut ser)); Ok(()) } @@ -367,7 +367,7 @@ pub fn to_writer_pretty(writer: &mut W, value: &T) -> io::Result<()> T: ser::Serialize, { let mut ser = Serializer::new_pretty(writer); - try!(value.visit(&mut ser)); + try!(value.serialize(&mut ser)); Ok(()) } diff --git a/src/json/value.rs b/src/json/value.rs index 0050dc73..aae566d7 100644 --- a/src/json/value.rs +++ b/src/json/value.rs @@ -21,7 +21,7 @@ pub enum Value { impl ser::Serialize for Value { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: ser::Serializer, { match *self { @@ -30,8 +30,8 @@ impl ser::Serialize for Value { 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), + Value::Array(ref v) => v.serialize(serializer), + Value::Object(ref v) => v.serialize(serializer), } } } @@ -210,7 +210,7 @@ impl ser::Serializer for Serializer { fn visit_some(&mut self, value: V) -> Result<(), ()> where V: ser::Serialize, { - value.visit(self) + value.serialize(self) } #[inline] @@ -278,7 +278,7 @@ impl ser::Serializer for Serializer { fn visit_seq_elt(&mut self, _first: bool, value: T) -> Result<(), ()> where T: ser::Serialize, { - try!(value.visit(self)); + try!(value.serialize(self)); let value = match self.state.pop().unwrap() { State::Value(value) => value, @@ -338,14 +338,14 @@ impl ser::Serializer for Serializer { where K: ser::Serialize, V: ser::Serialize, { - try!(key.visit(self)); + try!(key.serialize(self)); let key = match self.state.pop().unwrap() { State::Value(Value::String(value)) => value, state => panic!("expected key, found {:?}", state), }; - try!(value.visit(self)); + try!(value.serialize(self)); let value = match self.state.pop().unwrap() { State::Value(value) => value, @@ -577,7 +577,7 @@ pub fn to_value(value: &T) -> Value where T: ser::Serialize { let mut ser = Serializer::new(); - value.visit(&mut ser).ok().unwrap(); + value.serialize(&mut ser).ok().unwrap(); ser.unwrap() } diff --git a/src/ser.rs b/src/ser.rs index 31f7fab6..6eebba68 100644 --- a/src/ser.rs +++ b/src/ser.rs @@ -9,7 +9,7 @@ use std::sync::Arc; /////////////////////////////////////////////////////////////////////////////// pub trait Serialize { - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer; } @@ -185,7 +185,7 @@ macro_rules! impl_visit { ($ty:ty, $method:ident) => { impl Serialize for $ty { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { serializer.$method(*self) @@ -213,7 +213,7 @@ impl_visit!(char, visit_char); impl<'a> Serialize for &'a str { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { serializer.visit_str(*self) @@ -222,10 +222,10 @@ impl<'a> Serialize for &'a str { impl Serialize for String { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - (&self[..]).visit(serializer) + (&self[..]).serialize(serializer) } } @@ -233,7 +233,7 @@ impl Serialize for String { impl Serialize for Option where T: Serialize { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { match *self { @@ -294,7 +294,7 @@ impl<'a, T> Serialize for &'a [T] where T: Serialize, { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { serializer.visit_seq(SeqIteratorVisitor::new(self.iter())) @@ -303,16 +303,16 @@ impl<'a, T> Serialize for &'a [T] impl Serialize for Vec where T: Serialize { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - (&self[..]).visit(serializer) + (&self[..]).serialize(serializer) } } impl Serialize for BTreeSet where T: Serialize { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { serializer.visit_seq(SeqIteratorVisitor::new(self.iter())) @@ -324,7 +324,7 @@ impl Serialize for HashSet H: HashState, { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { serializer.visit_seq(SeqIteratorVisitor::new(self.iter())) @@ -335,7 +335,7 @@ impl Serialize for HashSet impl Serialize for () { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { serializer.visit_unit() @@ -403,7 +403,7 @@ macro_rules! tuple_impls { where $($T: Serialize),+ { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> { + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> { serializer.visit_seq($TupleVisitor::new(self)) } } @@ -569,7 +569,7 @@ impl Serialize for BTreeMap V: Serialize, { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { serializer.visit_map(MapIteratorVisitor::new(self.iter())) @@ -582,7 +582,7 @@ impl Serialize for HashMap H: HashState, { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { serializer.visit_map(MapIteratorVisitor::new(self.iter())) @@ -593,63 +593,63 @@ impl Serialize for HashMap impl<'a, T> Serialize for &'a T where T: Serialize { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - (**self).visit(serializer) + (**self).serialize(serializer) } } impl<'a, T> Serialize for &'a mut T where T: Serialize { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - (**self).visit(serializer) + (**self).serialize(serializer) } } impl Serialize for Box where T: Serialize { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - (**self).visit(serializer) + (**self).serialize(serializer) } } impl Serialize for Rc where T: Serialize, { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - (**self).visit(serializer) + (**self).serialize(serializer) } } impl Serialize for Arc where T: Serialize, { #[inline] - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - (**self).visit(serializer) + (**self).serialize(serializer) } } /////////////////////////////////////////////////////////////////////////////// impl Serialize for path::Path { - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - self.to_str().unwrap().visit(serializer) + self.to_str().unwrap().serialize(serializer) } } impl Serialize for path::PathBuf { - fn visit(&self, serializer: &mut S) -> Result<(), S::Error> + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer, { - self.to_str().unwrap().visit(serializer) + self.to_str().unwrap().serialize(serializer) } } diff --git a/tests/test_ser.rs b/tests/test_ser.rs index 4d5c185a..b7d86af9 100644 --- a/tests/test_ser.rs +++ b/tests/test_ser.rs @@ -180,7 +180,7 @@ impl<'a> Serializer for AssertSerializer<'a> { where V: Serialize, { 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 { assert_eq!(self.iter.next(), Some(Token::SeqSep(first))); - value.visit(self) + value.serialize(self) } fn visit_map(&mut self, visitor: V) -> Result<(), ()> @@ -266,8 +266,8 @@ impl<'a> Serializer for AssertSerializer<'a> { { assert_eq!(self.iter.next(), Some(Token::MapSep(first))); - try!(key.visit(self)); - value.visit(self) + try!(key.serialize(self)); + value.serialize(self) } } @@ -314,7 +314,7 @@ macro_rules! declare_test { fn $name() { $( let mut ser = AssertSerializer::new($tokens); - assert_eq!($value.visit(&mut ser), Ok(())); + assert_eq!($value.serialize(&mut ser), Ok(())); )+ } }