itsscb/serde
1
0
Fork 0
mirror of https://github.com/serde-rs/serde.git synced 2025-10-02 15:25:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update impls

Browse Source
This commit is contained in:
David Tolnay 2016-07-15 00:55:38 -07:00
parent 0feeb7a341
commit 9217517532
No known key found for this signature in database
GPG Key ID: F9BA143B95FF6D82
1 changed files with 59 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

161
serde/src/ser/impls.rs
View File

@ -152,11 +152,11 @@ impl<T> Serialize for [T]
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer, where S: Serializer,
{ {
let state = try!(serializer.serialize_seq(Some(self.len()))); let mut state = try!(serializer.serialize_seq(Some(self.len())));
for e in self.iter() { for e in self.iter() {
try!(serializer.serialize_seq_elt(e)); try!(serializer.serialize_seq_elt(&mut state, e));
} }
serializer.serialize_seq_end(Some(self.len()), state) serializer.serialize_seq_end(state)
} }
} }
@ -169,11 +169,11 @@ macro_rules! array_impls {
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer, where S: Serializer,
{ {
let state = try!(serializer.serialize_fixed_size_array($len)); let mut state = try!(serializer.serialize_seq(Some($len)));
for e in self.iter() { for e in self.iter() {
try!(serializer.serialize_seq_elt(e)); try!(serializer.serialize_seq_elt(&mut state, e));
} }
serializer.serialize_seq_end(Some(self.len()), state) serializer.serialize_seq_end(state)
} }
} }
} }
@ -215,52 +215,40 @@ array_impls!(32);
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#[cfg(any(feature = "std", feature = "collections"))] macro_rules! serialize_seq {
impl<T> Serialize for BinaryHeap<T> () => {
where T: Serialize + Ord
{
#[inline] #[inline]
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer, where S: Serializer,
{ {
let state = try!(serializer.serialize_seq(Some(self.len()))); let mut state = try!(serializer.serialize_seq(Some(self.len())));
for e in self.iter() { for e in self {
try!(serializer.serialize_seq_elt(e)); try!(serializer.serialize_seq_elt(&mut state, e));
} }
serializer.serialize_seq_end(Some(self.len()), state) serializer.serialize_seq_end(state)
} }
}
}
#[cfg(any(feature = "std", feature = "collections"))]
impl<T> Serialize for BinaryHeap<T>
where T: Serialize + Ord
{
serialize_seq!();
} }
#[cfg(any(feature = "std", feature = "collections"))] #[cfg(any(feature = "std", feature = "collections"))]
impl<T> Serialize for BTreeSet<T> impl<T> Serialize for BTreeSet<T>
where T: Serialize + Ord, where T: Serialize + Ord,
{ {
#[inline] serialize_seq!();
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
let state = try!(serializer.serialize_seq(Some(self.len())));
for e in self.iter() {
try!(serializer.serialize_seq_elt(e));
}
serializer.serialize_seq_end(Some(self.len()), state)
}
} }
#[cfg(all(feature = "nightly", feature = "collections"))] #[cfg(all(feature = "nightly", feature = "collections"))]
impl<T> Serialize for EnumSet<T> impl<T> Serialize for EnumSet<T>
where T: Serialize + CLike where T: Serialize + CLike
{ {
#[inline] serialize_seq!();
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
try!(serializer.serialize_seq(Some(self.len())));
for e in self.iter() {
try!(serializer.serialize_seq_elt(e));
}
serializer.serialize_seq_end(Some(self.len()))
}
} }
#[cfg(feature = "std")] #[cfg(feature = "std")]
@ -268,32 +256,24 @@ impl<T, H> Serialize for HashSet<T, H>
where T: Serialize + Eq + Hash, where T: Serialize + Eq + Hash,
H: BuildHasher, H: BuildHasher,
{ {
#[inline] serialize_seq!();
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
let state = try!(serializer.serialize_seq(Some(self.len())));
for e in self.iter() {
try!(serializer.serialize_seq_elt(e));
}
serializer.serialize_seq_end(Some(self.len()), state)
}
} }
#[cfg(any(feature = "std", feature = "collections"))] #[cfg(any(feature = "std", feature = "collections"))]
impl<T> Serialize for LinkedList<T> impl<T> Serialize for LinkedList<T>
where T: Serialize, where T: Serialize,
{ {
#[inline] serialize_seq!();
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> }
where S: Serializer,
{ #[cfg(any(feature = "std", feature = "collections"))]
let state = try!(serializer.serialize_seq(Some(self.len()))); impl<T> Serialize for Vec<T> where T: Serialize {
for e in self.iter() { serialize_seq!();
try!(serializer.serialize_seq_elt(e)); }
}
serializer.serialize_seq_end(Some(self.len()), state) #[cfg(any(feature = "std", feature = "collections"))]
} impl<T> Serialize for VecDeque<T> where T: Serialize {
serialize_seq!();
} }
#[cfg(feature = "nightly")] #[cfg(feature = "nightly")]
@ -306,35 +286,11 @@ impl<A> Serialize for ops::Range<A>
where S: Serializer, where S: Serializer,
{ {
let len = iter::Step::steps_between(&self.start, &self.end, &A::one()); let len = iter::Step::steps_between(&self.start, &self.end, &A::one());
let state = try!(serializer.serialize_seq(len)); let mut state = try!(serializer.serialize_seq(len));
for e in self.clone() { for e in self.clone() {
try!(serializer.serialize_seq_elt(e)); try!(serializer.serialize_seq_elt(&mut state, e));
} }
serializer.serialize_seq_end(len, state); serializer.serialize_seq_end(state)
}
}
#[cfg(any(feature = "std", feature = "collections"))]
impl<T> Serialize for Vec<T> where T: Serialize {
#[inline]
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
(&self[..]).serialize(serializer)
}
}
#[cfg(any(feature = "std", feature = "collections"))]
impl<T> Serialize for VecDeque<T> where T: Serialize {
#[inline]
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
let state = try!(serializer.serialize_seq(Some(self.len())));
for e in self.iter() {
try!(serializer.serialize_seq_elt(e));
}
serializer.serialize_seq_end(Some(self.len()), state)
} }
} }
@ -370,11 +326,11 @@ macro_rules! tuple_impls {
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer, where S: Serializer,
{ {
let state = try!(serializer.serialize_tuple($len)); let mut state = try!(serializer.serialize_tuple($len));
$( $(
try!(serializer.serialize_tuple_elt(&e!(self.$idx))); try!(serializer.serialize_tuple_elt(&mut state, &e!(self.$idx)));
)+ )+
serializer.serialize_tuple_end($len, state) serializer.serialize_tuple_end(state)
} }
} }
)+ )+
@ -554,21 +510,27 @@ tuple_impls! {
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
macro_rules! serialize_map {
() => {
#[inline]
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
let mut state = try!(serializer.serialize_map(Some(self.len())));
for (k, v) in self {
try!(serializer.serialize_map_elt(&mut state, k, v));
}
serializer.serialize_map_end(state)
}
}
}
#[cfg(any(feature = "std", feature = "collections"))] #[cfg(any(feature = "std", feature = "collections"))]
impl<K, V> Serialize for BTreeMap<K, V> impl<K, V> Serialize for BTreeMap<K, V>
where K: Serialize + Ord, where K: Serialize + Ord,
V: Serialize, V: Serialize,
{ {
#[inline] serialize_map!();
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
let state = try!(serializer.serialize_map(Some(self.len())));
for (k, v) in self.iter() {
try!(serializer.serialize_map_elt(k, v));
}
serializer.serialize_map_end(Some(self.len()), state)
}
} }
#[cfg(feature = "std")] #[cfg(feature = "std")]
@ -577,16 +539,7 @@ impl<K, V, H> Serialize for HashMap<K, V, H>
V: Serialize, V: Serialize,
H: BuildHasher, H: BuildHasher,
{ {
#[inline] serialize_map!();
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: Serializer,
{
let state = try!(serializer.serialize_map(Some(self.len())));
for (k, v) in self.iter() {
try!(serializer.serialize_map_elt(k, v));
}
serializer.serialize_map_end(Some(self.len()), state)
}
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////