mikros/serde
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #15 from tomprogrammer/rust-head

Browse Source 
Follow rustc changes: Various fixes due to std api stabilization
This commit is contained in:
Erick Tryzelaar 2014-12-23 13:02:10 -08:00
commit 1366bf47e7
20 changed files with 203 additions and 199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
benches/bench_log.rs
View File

@ -589,7 +589,7 @@ macro_rules! likely(
unsafe { expect(x as u8, 1) != 0 } unsafe { expect(x as u8, 1) != 0 }
} }
} }
) );
macro_rules! unlikely( macro_rules! unlikely(
($val:expr) => { ($val:expr) => {
@ -602,7 +602,7 @@ macro_rules! unlikely(
unsafe { expect(x as u8, 0) != 0 } unsafe { expect(x as u8, 0) != 0 }
} }
} }
) );
struct MyMemWriter0 { struct MyMemWriter0 {
buf: Vec<u8>, buf: Vec<u8>,

8
benches/bench_map.rs
View File

@ -28,7 +28,7 @@ pub enum Error {
mod decoder { mod decoder {
use std::collections::HashMap; use std::collections::HashMap;
use std::collections::hash_map::MoveEntries; use std::collections::hash_map::IntoIter;
use serialize; use serialize;
use super::Error; use super::Error;
@ -42,7 +42,7 @@ mod decoder {
pub struct IntDecoder { pub struct IntDecoder {
len: uint, len: uint,
iter: MoveEntries<String, int>, iter: IntoIter<String, int>,
stack: Vec<Value>, stack: Vec<Value>,
} }
@ -216,7 +216,7 @@ mod decoder {
mod deserializer { mod deserializer {
use std::collections::HashMap; use std::collections::HashMap;
use std::collections::hash_map::MoveEntries; use std::collections::hash_map::IntoIter;
use super::Error; use super::Error;
use super::Error::{EndOfStream, SyntaxError}; use super::Error::{EndOfStream, SyntaxError};
@ -235,7 +235,7 @@ mod deserializer {
pub struct IntDeserializer { pub struct IntDeserializer {
stack: Vec<State>, stack: Vec<State>,
len: uint, len: uint,
iter: MoveEntries<String, int>, iter: IntoIter<String, int>,
} }
impl IntDeserializer { impl IntDeserializer {

8
benches/bench_vec.rs
View File

@ -34,7 +34,7 @@ mod decoder {
pub struct IntDecoder { pub struct IntDecoder {
len: uint, len: uint,
iter: vec::MoveItems<int>, iter: vec::IntoIter<int>,
} }
impl IntDecoder { impl IntDecoder {
@ -186,7 +186,7 @@ mod decoder {
pub struct U8Decoder { pub struct U8Decoder {
len: uint, len: uint,
iter: vec::MoveItems<u8>, iter: vec::IntoIter<u8>,
} }
impl U8Decoder { impl U8Decoder {
@ -359,7 +359,7 @@ mod deserializer {
pub struct IntDeserializer { pub struct IntDeserializer {
state: State, state: State,
len: uint, len: uint,
iter: vec::MoveItems<int>, iter: vec::IntoIter<int>,
} }
impl IntDeserializer { impl IntDeserializer {
@ -431,7 +431,7 @@ mod deserializer {
pub struct U8Deserializer { pub struct U8Deserializer {
state: State, state: State,
len: uint, len: uint,
iter: vec::MoveItems<u8>, iter: vec::IntoIter<u8>,
} }
impl U8Deserializer { impl U8Deserializer {

4
serde2/benches/bench_log.rs
View File

@ -932,7 +932,7 @@ macro_rules! likely(
unsafe { expect(x as u8, 1) != 0 } unsafe { expect(x as u8, 1) != 0 }
} }
} }
) );
macro_rules! unlikely( macro_rules! unlikely(
($val:expr) => { ($val:expr) => {
@ -945,7 +945,7 @@ macro_rules! unlikely(
unsafe { expect(x as u8, 0) != 0 } unsafe { expect(x as u8, 0) != 0 }
} }
} }
) );
struct MyMemWriter0 { struct MyMemWriter0 {
buf: Vec<u8>, buf: Vec<u8>,

10
serde2/src/bin.rs
View File

@ -253,7 +253,7 @@ impl<
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
mod json { mod json {
use std::collections::TreeMap; use std::collections::BTreeMap;
use serde2::de; use serde2::de;
#[deriving(Show)] #[deriving(Show)]
@ -263,7 +263,7 @@ mod json {
Int(int), Int(int),
//String(String), //String(String),
List(Vec<Value>), List(Vec<Value>),
Map(TreeMap<String, Value>), Map(BTreeMap<String, Value>),
} }
impl< impl<
@ -323,7 +323,7 @@ mod json {
fn visit_map< fn visit_map<
Visitor: de::MapVisitor<D, E>, Visitor: de::MapVisitor<D, E>,
>(&mut self, mut visitor: Visitor) -> Result<Value, E> { >(&mut self, mut visitor: Visitor) -> Result<Value, E> {
let mut values = TreeMap::new(); let mut values = BTreeMap::new();
loop { loop {
match try!(visitor.visit()) { match try!(visitor.visit()) {
@ -500,7 +500,7 @@ pub fn main() {
/* /*
use std::collections::TreeMap; use std::collections::BTreeMap;
use serde::{Serialize, GatherTokens}; use serde::{Serialize, GatherTokens};
use serde::json; use serde::json;
@ -578,7 +578,7 @@ fn main() {
//// ////
let mut value = TreeMap::new(); let mut value = BTreeMap::new();
value.insert("a", 1i); value.insert("a", 1i);
value.insert("b", 2); value.insert("b", 2);
value.insert("c", 3); value.insert("c", 3);

64
serde2/src/de.rs
View File

@ -1,4 +1,4 @@
use std::collections::{HashMap, TreeMap}; use std::collections::{HashMap, BTreeMap};
use std::hash::Hash; use std::hash::Hash;
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
@ -237,18 +237,18 @@ pub fn deserialize_from_primitive<
E: Error, E: Error,
T: Deserialize<S, E> + FromPrimitive T: Deserialize<S, E> + FromPrimitive
> self::Visitor<S, T, E> for Visitor { > self::Visitor<S, T, E> for Visitor {
impl_deserialize_num_method!(int, visit_int, from_int) impl_deserialize_num_method!(int, visit_int, from_int);
impl_deserialize_num_method!(i8, visit_i8, from_i8) impl_deserialize_num_method!(i8, visit_i8, from_i8);
impl_deserialize_num_method!(i16, visit_i16, from_i16) impl_deserialize_num_method!(i16, visit_i16, from_i16);
impl_deserialize_num_method!(i32, visit_i32, from_i32) impl_deserialize_num_method!(i32, visit_i32, from_i32);
impl_deserialize_num_method!(i64, visit_i64, from_i64) impl_deserialize_num_method!(i64, visit_i64, from_i64);
impl_deserialize_num_method!(uint, visit_uint, from_uint) impl_deserialize_num_method!(uint, visit_uint, from_uint);
impl_deserialize_num_method!(u8, visit_u8, from_u8) impl_deserialize_num_method!(u8, visit_u8, from_u8);
impl_deserialize_num_method!(u16, visit_u16, from_u16) impl_deserialize_num_method!(u16, visit_u16, from_u16);
impl_deserialize_num_method!(u32, visit_u32, from_u32) impl_deserialize_num_method!(u32, visit_u32, from_u32);
impl_deserialize_num_method!(u64, visit_u64, from_u64) impl_deserialize_num_method!(u64, visit_u64, from_u64);
impl_deserialize_num_method!(f32, visit_f32, from_f32) impl_deserialize_num_method!(f32, visit_f32, from_f32);
impl_deserialize_num_method!(f64, visit_f64, from_f64) impl_deserialize_num_method!(f64, visit_f64, from_f64);
} }
state.visit(&mut Visitor) state.visit(&mut Visitor)
@ -268,18 +268,18 @@ macro_rules! impl_deserialize_num {
} }
} }
impl_deserialize_num!(int) impl_deserialize_num!(int);
impl_deserialize_num!(i8) impl_deserialize_num!(i8);
impl_deserialize_num!(i16) impl_deserialize_num!(i16);
impl_deserialize_num!(i32) impl_deserialize_num!(i32);
impl_deserialize_num!(i64) impl_deserialize_num!(i64);
impl_deserialize_num!(uint) impl_deserialize_num!(uint);
impl_deserialize_num!(u8) impl_deserialize_num!(u8);
impl_deserialize_num!(u16) impl_deserialize_num!(u16);
impl_deserialize_num!(u32) impl_deserialize_num!(u32);
impl_deserialize_num!(u64) impl_deserialize_num!(u64);
impl_deserialize_num!(f32) impl_deserialize_num!(f32);
impl_deserialize_num!(f64) impl_deserialize_num!(f64);
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
@ -377,14 +377,14 @@ impl<
macro_rules! peel { macro_rules! peel {
($name:ident, $($other:ident,)*) => { ($name:ident, $($other:ident,)*) => {
impl_deserialize_tuple!($($other,)*) impl_deserialize_tuple!($($other,)*);
} }
} }
macro_rules! impl_deserialize_tuple { macro_rules! impl_deserialize_tuple {
() => {}; () => {};
( $($name:ident,)+ ) => { ( $($name:ident,)+ ) => {
peel!($($name,)*) peel!($($name,)*);
impl< impl<
S: Deserializer<E>, S: Deserializer<E>,
@ -472,8 +472,8 @@ impl<
V: Deserialize<S, E>, V: Deserialize<S, E>,
S: Deserializer<E>, S: Deserializer<E>,
E: Error, E: Error,
> Deserialize<S, E> for TreeMap<K, V> { > Deserialize<S, E> for BTreeMap<K, V> {
fn deserialize(state: &mut S) -> Result<TreeMap<K, V>, E> { fn deserialize(state: &mut S) -> Result<BTreeMap<K, V>, E> {
struct Visitor; struct Visitor;
impl< impl<
@ -481,11 +481,11 @@ impl<
V: Deserialize<S, E>, V: Deserialize<S, E>,
S: Deserializer<E>, S: Deserializer<E>,
E: Error, E: Error,
> self::Visitor<S, TreeMap<K, V>, E> for Visitor { > self::Visitor<S, BTreeMap<K, V>, E> for Visitor {
fn visit_map< fn visit_map<
Visitor: MapVisitor<S, E>, Visitor: MapVisitor<S, E>,
>(&mut self, mut visitor: Visitor) -> Result<TreeMap<K, V>, E> { >(&mut self, mut visitor: Visitor) -> Result<BTreeMap<K, V>, E> {
let mut values = TreeMap::new(); let mut values = BTreeMap::new();
loop { loop {
match try!(visitor.visit()) { match try!(visitor.visit()) {

27
serde2/src/json/builder.rs
View File

@ -8,8 +8,7 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use std::collections::TreeMap; use std::collections::BTreeMap;
use std::str::StrAllocating;
use ser::{mod, Serialize}; use ser::{mod, Serialize};
use json::value::{mod, Value}; use json::value::{mod, Value};
@ -46,39 +45,39 @@ impl ArrayBuilder {
} }
pub struct ObjectBuilder { pub struct ObjectBuilder {
object: TreeMap<String, Value>, object: BTreeMap<String, Value>,
} }
impl ObjectBuilder { impl ObjectBuilder {
pub fn new() -> ObjectBuilder { pub fn new() -> ObjectBuilder {
ObjectBuilder { object: TreeMap::new() } ObjectBuilder { object: BTreeMap::new() }
} }
pub fn unwrap(self) -> Value { pub fn unwrap(self) -> Value {
Value::Object(self.object) Value::Object(self.object)
} }
pub fn insert<K: StrAllocating, V: ser::Serialize>(mut self, k: K, v: V) -> ObjectBuilder { pub fn insert<V: ser::Serialize>(mut self, k: String, v: V) -> ObjectBuilder {
self.object.insert(k.into_string(), value::to_value(&v)); self.object.insert(k, value::to_value(&v));
self self
} }
pub fn insert_array<S: StrAllocating>(mut self, key: S, f: |ArrayBuilder| -> ArrayBuilder) -> ObjectBuilder { pub fn insert_array(mut self, key: String, f: |ArrayBuilder| -> ArrayBuilder) -> ObjectBuilder {
let builder = ArrayBuilder::new(); let builder = ArrayBuilder::new();
self.object.insert(key.into_string(), f(builder).unwrap()); self.object.insert(key, f(builder).unwrap());
self self
} }
pub fn insert_object<S: StrAllocating>(mut self, key: S, f: |ObjectBuilder| -> ObjectBuilder) -> ObjectBuilder { pub fn insert_object(mut self, key: String, f: |ObjectBuilder| -> ObjectBuilder) -> ObjectBuilder {
let builder = ObjectBuilder::new(); let builder = ObjectBuilder::new();
self.object.insert(key.into_string(), f(builder).unwrap()); self.object.insert(key, f(builder).unwrap());
self self
} }
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use std::collections::TreeMap; use std::collections::BTreeMap;
use json::value::Value; use json::value::Value;
use super::{ArrayBuilder, ObjectBuilder}; use super::{ArrayBuilder, ObjectBuilder};
@ -107,7 +106,7 @@ mod tests {
.insert("b".to_string(), 2i)) .insert("b".to_string(), 2i))
.unwrap(); .unwrap();
let mut map = TreeMap::new(); let mut map = BTreeMap::new();
map.insert("a".to_string(), Value::I64(1)); map.insert("a".to_string(), Value::I64(1));
map.insert("b".to_string(), Value::I64(2)); map.insert("b".to_string(), Value::I64(2));
assert_eq!(value, Value::Array(vec!(Value::Object(map)))); assert_eq!(value, Value::Array(vec!(Value::Object(map))));
@ -116,14 +115,14 @@ mod tests {
#[test] #[test]
fn test_object_builder() { fn test_object_builder() {
let value = ObjectBuilder::new().unwrap(); let value = ObjectBuilder::new().unwrap();
assert_eq!(value, Value::Object(TreeMap::new())); assert_eq!(value, Value::Object(BTreeMap::new()));
let value = ObjectBuilder::new() let value = ObjectBuilder::new()
.insert("a".to_string(), 1i) .insert("a".to_string(), 1i)
.insert("b".to_string(), 2i) .insert("b".to_string(), 2i)
.unwrap(); .unwrap();
let mut map = TreeMap::new(); let mut map = BTreeMap::new();
map.insert("a".to_string(), Value::I64(1)); map.insert("a".to_string(), Value::I64(1));
map.insert("b".to_string(), Value::I64(2)); map.insert("b".to_string(), Value::I64(2));
assert_eq!(value, Value::Object(map)); assert_eq!(value, Value::Object(map));

12
serde2/src/json/de.rs
View File

@ -1,6 +1,6 @@
use std::char; use std::char;
use std::num::Float; use std::num::Float;
use std::str::ScalarValue; use unicode::str::Utf16Item;
use std::str; use std::str;
use de; use de;
@ -337,8 +337,8 @@ impl<Iter: Iterator<u8>> Parser<Iter> {
} }
let buf = &[n1, try!(self.decode_hex_escape())]; let buf = &[n1, try!(self.decode_hex_escape())];
match str::utf16_items(buf.as_slice()).next() { match ::unicode::str::utf16_items(buf.as_slice()).next() {
Some(ScalarValue(c)) => c, Some(Utf16Item::ScalarValue(c)) => c,
_ => { _ => {
return Err(self.error(ErrorCode::LoneLeadingSurrogateInHexEscape)); return Err(self.error(ErrorCode::LoneLeadingSurrogateInHexEscape));
} }
@ -529,7 +529,7 @@ pub fn from_str<
mod tests { mod tests {
use std::str; use std::str;
use std::fmt::Show; use std::fmt::Show;
use std::collections::TreeMap; use std::collections::BTreeMap;
use de::Deserialize; use de::Deserialize;
use super::{Parser, from_str}; use super::{Parser, from_str};
@ -537,7 +537,7 @@ mod tests {
macro_rules! treemap { macro_rules! treemap {
($($k:expr => $v:expr),*) => ({ ($($k:expr => $v:expr),*) => ({
let mut _m = TreeMap::new(); let mut _m = BTreeMap::new();
$(_m.insert($k, $v);)* $(_m.insert($k, $v);)*
_m _m
}) })
@ -694,7 +694,7 @@ mod tests {
#[test] #[test]
fn test_parse_object() { fn test_parse_object() {
test_parse_err::<TreeMap<String, int>>(vec![ test_parse_err::<BTreeMap<String, int>>(vec![
("{", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 2)), ("{", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 2)),
("{ ", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 3)), ("{ ", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 3)),
("{1", Error::SyntaxError(ErrorCode::KeyMustBeAString, 1, 2)), ("{1", Error::SyntaxError(ErrorCode::KeyMustBeAString, 1, 2)),

3
serde2/src/json/ser.rs
View File

@ -1,6 +1,7 @@
use std::f64; use std::f64;
use std::io::{mod, ByRefWriter, IoError}; use std::io::{mod, ByRefWriter, IoError};
use std::num::{Float, FPNaN, FPInfinite}; use std::num::{Float, FPNaN, FPInfinite};
use std::str::Utf8Error;
use ser; use ser;
use ser::Serializer; use ser::Serializer;
@ -251,7 +252,7 @@ pub fn to_vec<
#[inline] #[inline]
pub fn to_string< pub fn to_string<
T: ser::Serialize, T: ser::Serialize,
>(value: &T) -> Result<Result<String, Vec<u8>>, IoError> { >(value: &T) -> Result<Result<String, (Vec<u8>, Utf8Error)>, IoError> {
let vec = try!(to_vec(value)); let vec = try!(to_vec(value));
Ok(String::from_utf8(vec)) Ok(String::from_utf8(vec))
} }

8
serde2/src/json/value.rs
View File

@ -1,4 +1,4 @@
use std::collections::TreeMap; use std::collections::BTreeMap;
use std::fmt; use std::fmt;
use std::io; use std::io;
@ -12,7 +12,7 @@ pub enum Value {
F64(f64), F64(f64),
String(String), String(String),
Array(Vec<Value>), Array(Vec<Value>),
Object(TreeMap<String, Value>), Object(BTreeMap<String, Value>),
} }
impl ser::Serialize for Value { impl ser::Serialize for Value {
@ -77,7 +77,7 @@ pub fn to_value<
enum State { enum State {
Value(Value), Value(Value),
Array(Vec<Value>), Array(Vec<Value>),
Object(TreeMap<String, Value>), Object(BTreeMap<String, Value>),
} }
pub struct Writer { pub struct Writer {
@ -203,7 +203,7 @@ impl ser::Visitor<Writer, (), ()> for Visitor {
fn visit_map< fn visit_map<
V: ser::MapVisitor<Writer, (), ()> V: ser::MapVisitor<Writer, (), ()>
>(&self, state: &mut Writer, mut visitor: V) -> Result<(), ()> { >(&self, state: &mut Writer, mut visitor: V) -> Result<(), ()> {
let values = TreeMap::new(); let values = BTreeMap::new();
state.state.push(State::Object(values)); state.state.push(State::Object(values));

2
serde2/src/lib.rs
View File

@ -1,5 +1,7 @@
#![feature(macro_rules)] #![feature(macro_rules)]
extern crate unicode;
pub use ser::{Serialize, Serializer}; pub use ser::{Serialize, Serializer};
//pub use ser::{Visitor, VisitorState}; //pub use ser::{Visitor, VisitorState};
//pub use ser::GatherTokens; //pub use ser::GatherTokens;

32
serde2/src/ser.rs
View File

@ -1,4 +1,4 @@
use std::collections::TreeMap; use std::collections::BTreeMap;
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
@ -176,20 +176,20 @@ macro_rules! impl_visit {
} }
} }
impl_visit!(bool, visit_bool) impl_visit!(bool, visit_bool);
impl_visit!(int, visit_int) impl_visit!(int, visit_int);
impl_visit!(i8, visit_i8) impl_visit!(i8, visit_i8);
impl_visit!(i16, visit_i16) impl_visit!(i16, visit_i16);
impl_visit!(i32, visit_i32) impl_visit!(i32, visit_i32);
impl_visit!(i64, visit_i64) impl_visit!(i64, visit_i64);
impl_visit!(uint, visit_uint) impl_visit!(uint, visit_uint);
impl_visit!(u8, visit_u8) impl_visit!(u8, visit_u8);
impl_visit!(u16, visit_u16) impl_visit!(u16, visit_u16);
impl_visit!(u32, visit_u32) impl_visit!(u32, visit_u32);
impl_visit!(u64, visit_u64) impl_visit!(u64, visit_u64);
impl_visit!(f32, visit_f32) impl_visit!(f32, visit_f32);
impl_visit!(f64, visit_f64) impl_visit!(f64, visit_f64);
impl_visit!(char, visit_char) impl_visit!(char, visit_char);
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
@ -491,7 +491,7 @@ impl<
impl< impl<
K: Serialize + Ord, K: Serialize + Ord,
V: Serialize, V: Serialize,
> Serialize for TreeMap<K, V> { > Serialize for BTreeMap<K, V> {
#[inline] #[inline]
fn visit< fn visit<
S, S,

74
src/de.rs
View File

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use std::collections::{HashMap, HashSet, TreeMap, TreeSet}; use std::collections::{HashMap, HashSet, BTreeMap, BTreeSet};
use std::hash::Hash; use std::hash::Hash;
use std::num; use std::num;
use std::rc::Rc; use std::rc::Rc;
@ -288,10 +288,10 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
fn expect_char(&mut self, token: Token) -> Result<char, E> { fn expect_char(&mut self, token: Token) -> Result<char, E> {
match token { match token {
Token::Char(value) => Ok(value), Token::Char(value) => Ok(value),
Token::Str(value) if value.char_len() == 1 => { Token::Str(value) if value.chars().count() == 1 => {
Ok(value.char_at(0)) Ok(value.char_at(0))
} }
Token::String(ref value) if value.as_slice().char_len() == 1 => { Token::String(ref value) if value.as_slice().chars().count() == 1 => {
Ok(value.as_slice().char_at(0)) Ok(value.as_slice().char_at(0))
} }
token => { token => {
@ -673,22 +673,22 @@ macro_rules! impl_deserialize {
} }
} }
impl_deserialize!(bool, expect_bool) impl_deserialize!(bool, expect_bool);
impl_deserialize!(int, expect_num) impl_deserialize!(int, expect_num);
impl_deserialize!(i8, expect_num) impl_deserialize!(i8, expect_num);
impl_deserialize!(i16, expect_num) impl_deserialize!(i16, expect_num);
impl_deserialize!(i32, expect_num) impl_deserialize!(i32, expect_num);
impl_deserialize!(i64, expect_num) impl_deserialize!(i64, expect_num);
impl_deserialize!(uint, expect_num) impl_deserialize!(uint, expect_num);
impl_deserialize!(u8, expect_num) impl_deserialize!(u8, expect_num);
impl_deserialize!(u16, expect_num) impl_deserialize!(u16, expect_num);
impl_deserialize!(u32, expect_num) impl_deserialize!(u32, expect_num);
impl_deserialize!(u64, expect_num) impl_deserialize!(u64, expect_num);
impl_deserialize!(f32, expect_num) impl_deserialize!(f32, expect_num);
impl_deserialize!(f64, expect_num) impl_deserialize!(f64, expect_num);
impl_deserialize!(char, expect_char) impl_deserialize!(char, expect_char);
impl_deserialize!(&'static str, expect_str) impl_deserialize!(&'static str, expect_str);
impl_deserialize!(string::String, expect_string) impl_deserialize!(string::String, expect_string);
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
@ -770,9 +770,9 @@ impl<
E, E,
K: Deserialize<D, E> + Ord, K: Deserialize<D, E> + Ord,
V: Deserialize<D, E> V: Deserialize<D, E>
> Deserialize<D, E> for TreeMap<K, V> { > Deserialize<D, E> for BTreeMap<K, V> {
#[inline] #[inline]
fn deserialize_token(d: &mut D, token: Token) -> Result<TreeMap<K, V>, E> { fn deserialize_token(d: &mut D, token: Token) -> Result<BTreeMap<K, V>, E> {
d.expect_map(token) d.expect_map(token)
} }
} }
@ -794,9 +794,9 @@ impl<
D: Deserializer<E>, D: Deserializer<E>,
E, E,
T: Deserialize<D, E> + Ord T: Deserialize<D, E> + Ord
> Deserialize<D, E> for TreeSet<T> { > Deserialize<D, E> for BTreeSet<T> {
#[inline] #[inline]
fn deserialize_token(d: &mut D, token: Token) -> Result<TreeSet<T>, E> { fn deserialize_token(d: &mut D, token: Token) -> Result<BTreeSet<T>, E> {
d.expect_seq(token) d.expect_seq(token)
} }
} }
@ -804,7 +804,7 @@ impl<
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
macro_rules! peel { macro_rules! peel {
($name:ident, $($other:ident,)*) => (impl_deserialize_tuple!($($other,)*)) ($name:ident, $($other:ident,)*) => ( impl_deserialize_tuple!($($other,)*); )
} }
macro_rules! impl_deserialize_tuple { macro_rules! impl_deserialize_tuple {
@ -840,7 +840,7 @@ macro_rules! impl_deserialize_tuple {
Ok(result) Ok(result)
} }
} }
peel!($($name,)*) peel!($($name,)*);
} }
} }
@ -1067,7 +1067,7 @@ impl<D: Deserializer<E>, E> Deserialize<D, E> for GatherTokens {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use std::collections::TreeMap; use std::collections::BTreeMap;
use std::{option, string}; use std::{option, string};
use serialize::Decoder; use serialize::Decoder;
@ -1075,7 +1075,7 @@ mod tests {
macro_rules! treemap { macro_rules! treemap {
($($k:expr => $v:expr),*) => ({ ($($k:expr => $v:expr),*) => ({
let mut _m = ::std::collections::TreeMap::new(); let mut _m = ::std::collections::BTreeMap::new();
$(_m.insert($k, $v);)* $(_m.insert($k, $v);)*
_m _m
}) })
@ -1087,7 +1087,7 @@ mod tests {
struct Inner { struct Inner {
a: (), a: (),
b: uint, b: uint,
c: TreeMap<string::String, option::Option<char>>, c: BTreeMap<string::String, option::Option<char>>,
} }
impl< impl<
@ -1276,7 +1276,7 @@ mod tests {
vec!(Token::Char('c')) => 'c': char, vec!(Token::Char('c')) => 'c': char,
vec!(Token::Str("abc")) => "abc": &str, vec!(Token::Str("abc")) => "abc": &str,
vec!(Token::String("abc".to_string())) => "abc".to_string(): string::String vec!(Token::String("abc".to_string())) => "abc".to_string(): string::String
]) ]);
test_value!(test_tuples, [ test_value!(test_tuples, [
vec!( vec!(
@ -1306,7 +1306,7 @@ mod tests {
Token::End, Token::End,
Token::End, Token::End,
) => ((), (), (5, "a")): ((), (), (int, &'static str)) ) => ((), (), (5, "a")): ((), (), (int, &'static str))
]) ]);
test_value!(test_options, [ test_value!(test_options, [
vec!(Token::Option(false)) => None: option::Option<int>, vec!(Token::Option(false)) => None: option::Option<int>,
@ -1315,7 +1315,7 @@ mod tests {
Token::Option(true), Token::Option(true),
Token::Int(5), Token::Int(5),
) => Some(5): option::Option<int> ) => Some(5): option::Option<int>
]) ]);
test_value!(test_structs, [ test_value!(test_structs, [
vec!( vec!(
@ -1356,7 +1356,7 @@ mod tests {
}, },
), ),
}: Outer }: Outer
]) ]);
test_value!(test_enums, [ test_value!(test_enums, [
vec!( vec!(
@ -1370,7 +1370,7 @@ mod tests {
Token::Int(349), Token::Int(349),
Token::End, Token::End,
) => Animal::Frog("Henry".to_string(), 349): Animal ) => Animal::Frog("Henry".to_string(), 349): Animal
]) ]);
test_value!(test_vecs, [ test_value!(test_vecs, [
vec!( vec!(
@ -1410,13 +1410,13 @@ mod tests {
Token::End, Token::End,
Token::End, Token::End,
) => vec!(vec!(1), vec!(2, 3), vec!(4, 5, 6)): Vec<Vec<int>> ) => vec!(vec!(1), vec!(2, 3), vec!(4, 5, 6)): Vec<Vec<int>>
]) ]);
test_value!(test_treemaps, [ test_value!(test_treemaps, [
vec!( vec!(
Token::MapStart(0), Token::MapStart(0),
Token::End, Token::End,
) => treemap!(): TreeMap<int, string::String>, ) => treemap!(): BTreeMap<int, string::String>,
vec!( vec!(
Token::MapStart(2), Token::MapStart(2),
@ -1426,7 +1426,7 @@ mod tests {
Token::Int(6), Token::Int(6),
Token::String("b".to_string()), Token::String("b".to_string()),
Token::End, Token::End,
) => treemap!(5i => "a".to_string(), 6i => "b".to_string()): TreeMap<int, string:: ) => treemap!(5i => "a".to_string(), 6i => "b".to_string()): BTreeMap<int, string::
String> String>
]) ]);
} }

27
src/json/builder.rs
View File

@ -8,8 +8,7 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use std::collections::TreeMap; use std::collections::BTreeMap;
use std::str::StrAllocating;
use json::value::{ToJson, Value}; use json::value::{ToJson, Value};
@ -44,38 +43,38 @@ impl ArrayBuilder {
} }
pub struct ObjectBuilder { pub struct ObjectBuilder {
object: TreeMap<String, Value>, object: BTreeMap<String, Value>,
} }
impl ObjectBuilder { impl ObjectBuilder {
pub fn new() -> ObjectBuilder { pub fn new() -> ObjectBuilder {
ObjectBuilder { object: TreeMap::new() } ObjectBuilder { object: BTreeMap::new() }
} }
pub fn unwrap(self) -> Value { pub fn unwrap(self) -> Value {
Value::Object(self.object) Value::Object(self.object)
} }
pub fn insert<K: StrAllocating, V: ToJson>(self, key: K, value: V) -> ObjectBuilder { pub fn insert<V: ToJson>(self, key: String, value: V) -> ObjectBuilder {
let mut builder = self; let mut builder = self;
builder.object.insert(key.into_string(), value.to_json()); builder.object.insert(key, value.to_json());
builder builder
} }
pub fn insert_array<S: StrAllocating>(self, key: S, f: |ArrayBuilder| -> ArrayBuilder) -> ObjectBuilder { pub fn insert_array(self, key: String, f: |ArrayBuilder| -> ArrayBuilder) -> ObjectBuilder {
let builder = ArrayBuilder::new(); let builder = ArrayBuilder::new();
self.insert(key.into_string(), f(builder).unwrap()) self.insert(key, f(builder).unwrap())
} }
pub fn insert_object<S: StrAllocating>(self, key: S, f: |ObjectBuilder| -> ObjectBuilder) -> ObjectBuilder { pub fn insert_object(self, key: String, f: |ObjectBuilder| -> ObjectBuilder) -> ObjectBuilder {
let builder = ObjectBuilder::new(); let builder = ObjectBuilder::new();
self.insert(key.into_string(), f(builder).unwrap()) self.insert(key, f(builder).unwrap())
} }
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use std::collections::TreeMap; use std::collections::BTreeMap;
use json::value::Value; use json::value::Value;
use super::{ArrayBuilder, ObjectBuilder}; use super::{ArrayBuilder, ObjectBuilder};
@ -104,7 +103,7 @@ mod tests {
.insert("b".to_string(), 2i)) .insert("b".to_string(), 2i))
.unwrap(); .unwrap();
let mut map = TreeMap::new(); let mut map = BTreeMap::new();
map.insert("a".to_string(), Value::Integer(1)); map.insert("a".to_string(), Value::Integer(1));
map.insert("b".to_string(), Value::Integer(2)); map.insert("b".to_string(), Value::Integer(2));
assert_eq!(value, Value::Array(vec!(Value::Object(map)))); assert_eq!(value, Value::Array(vec!(Value::Object(map))));
@ -113,14 +112,14 @@ mod tests {
#[test] #[test]
fn test_object_builder() { fn test_object_builder() {
let value = ObjectBuilder::new().unwrap(); let value = ObjectBuilder::new().unwrap();
assert_eq!(value, Value::Object(TreeMap::new())); assert_eq!(value, Value::Object(BTreeMap::new()));
let value = ObjectBuilder::new() let value = ObjectBuilder::new()
.insert("a".to_string(), 1i) .insert("a".to_string(), 1i)
.insert("b".to_string(), 2i) .insert("b".to_string(), 2i)
.unwrap(); .unwrap();
let mut map = TreeMap::new(); let mut map = BTreeMap::new();
map.insert("a".to_string(), Value::Integer(1)); map.insert("a".to_string(), Value::Integer(1));
map.insert("b".to_string(), Value::Integer(2)); map.insert("b".to_string(), Value::Integer(2));
assert_eq!(value, Value::Object(map)); assert_eq!(value, Value::Object(map));

6
src/json/de.rs
View File

@ -1,6 +1,6 @@
use std::str; use std::str;
use std::num::Float; use std::num::Float;
use std::str::ScalarValue; use unicode::str::Utf16Item;
use std::char; use std::char;
use de; use de;
@ -379,8 +379,8 @@ impl<Iter: Iterator<u8>> Parser<Iter> {
} }
let buf = &[n1, try!(self.decode_hex_escape())]; let buf = &[n1, try!(self.decode_hex_escape())];
match str::utf16_items(buf.as_slice()).next() { match ::unicode::str::utf16_items(buf.as_slice()).next() {
Some(ScalarValue(c)) => c, Some(Utf16Item::ScalarValue(c)) => c,
_ => { _ => {
return Err(self.error(ErrorCode::LoneLeadingSurrogateInHexEscape)); return Err(self.error(ErrorCode::LoneLeadingSurrogateInHexEscape));
} }

36
src/json/mod.rs
View File

@ -106,7 +106,7 @@ the API provide writer to serialize them into a stream or a string ...
When using `ToJson` the `Serialize` trait implementation is not mandatory. When using `ToJson` the `Serialize` trait implementation is not mandatory.
A basic `ToJson` example using a TreeMap of attribute name / attribute value: A basic `ToJson` example using a BTreeMap of attribute name / attribute value:
```rust ```rust
@ -115,7 +115,7 @@ A basic `ToJson` example using a TreeMap of attribute name / attribute value:
extern crate serde_macros; extern crate serde_macros;
extern crate serde; extern crate serde;
use std::collections::TreeMap; use std::collections::BTreeMap;
use serde::json::{ToJson, Value}; use serde::json::{ToJson, Value};
pub struct MyStruct { pub struct MyStruct {
@ -125,7 +125,7 @@ pub struct MyStruct {
impl ToJson for MyStruct { impl ToJson for MyStruct {
fn to_json( &self ) -> Value { fn to_json( &self ) -> Value {
let mut d = TreeMap::new(); let mut d = BTreeMap::new();
d.insert("attr1".to_string(), self.attr1.to_json()); d.insert("attr1".to_string(), self.attr1.to_json());
d.insert("attr2".to_string(), self.attr2.to_json()); d.insert("attr2".to_string(), self.attr2.to_json());
d.to_json() d.to_json()
@ -157,8 +157,8 @@ pub struct MyStruct {
impl ToJson for MyStruct { impl ToJson for MyStruct {
fn to_json( &self ) -> Value { fn to_json( &self ) -> Value {
ObjectBuilder::new() ObjectBuilder::new()
.insert("attr1", &self.attr1) .insert("attr1".to_string(), &self.attr1)
.insert("attr2", &self.attr2) .insert("attr2".to_string(), &self.attr2)
.unwrap() .unwrap()
} }
} }
@ -265,9 +265,9 @@ pub struct TestStruct1 {
impl ToJson for TestStruct1 { impl ToJson for TestStruct1 {
fn to_json( &self ) -> json::Value { fn to_json( &self ) -> json::Value {
json::builder::ObjectBuilder::new() json::builder::ObjectBuilder::new()
.insert("data_int", &self.data_int) .insert("data_int".to_string(), &self.data_int)
.insert("data_str", &self.data_str) .insert("data_str".to_string(), &self.data_str)
.insert("data_vector", &self.data_vector) .insert("data_vector".to_string(), &self.data_vector)
.unwrap() .unwrap()
} }
} }
@ -281,7 +281,7 @@ fn main() {
data_vector: vec![2,3,4,5], data_vector: vec![2,3,4,5],
}; };
let json: json::Value = test.to_json(); let json: json::Value = test.to_json();
let json_str: String = json.to_string().into_string(); let json_str: String = json.to_string();
// Deserialize like before. // Deserialize like before.
@ -322,7 +322,7 @@ mod tests {
use std::io; use std::io;
use std::str; use std::str;
use std::string; use std::string;
use std::collections::TreeMap; use std::collections::BTreeMap;
use de; use de;
use ser::{Serialize, Serializer}; use ser::{Serialize, Serializer};
@ -351,7 +351,7 @@ mod tests {
macro_rules! treemap { macro_rules! treemap {
($($k:expr => $v:expr),*) => ({ ($($k:expr => $v:expr),*) => ({
let mut _m = ::std::collections::TreeMap::new(); let mut _m = ::std::collections::BTreeMap::new();
$(_m.insert($k, $v);)* $(_m.insert($k, $v);)*
_m _m
}) })
@ -1002,7 +1002,7 @@ mod tests {
#[test] #[test]
fn test_parse_object() { fn test_parse_object() {
test_parse_err::<TreeMap<string::String, int>>(&[ test_parse_err::<BTreeMap<string::String, int>>(&[
("{", SyntaxError(EOFWhileParsingString, 1, 2)), ("{", SyntaxError(EOFWhileParsingString, 1, 2)),
("{ ", SyntaxError(EOFWhileParsingString, 1, 3)), ("{ ", SyntaxError(EOFWhileParsingString, 1, 3)),
("{1", SyntaxError(KeyMustBeAString, 1, 2)), ("{1", SyntaxError(KeyMustBeAString, 1, 2)),
@ -1171,7 +1171,7 @@ mod tests {
#[test] #[test]
fn test_multiline_errors() { fn test_multiline_errors() {
test_parse_err::<TreeMap<string::String, string::String>>(&[ test_parse_err::<BTreeMap<string::String, string::String>>(&[
("{\n \"foo\":\n \"bar\"", SyntaxError(EOFWhileParsingObject, 3u, 8u)), ("{\n \"foo\":\n \"bar\"", SyntaxError(EOFWhileParsingObject, 3u, 8u)),
]); ]);
} }
@ -1267,7 +1267,7 @@ mod tests {
fn test_as_object() { fn test_as_object() {
let json_value: Value = from_str("{}").unwrap(); let json_value: Value = from_str("{}").unwrap();
let json_object = json_value.as_object(); let json_object = json_value.as_object();
let map = TreeMap::<string::String, Value>::new(); let map = BTreeMap::<string::String, Value>::new();
assert_eq!(json_object, Some(&map)); assert_eq!(json_object, Some(&map));
} }
@ -1698,7 +1698,7 @@ mod tests {
#[cfg(test)] #[cfg(test)]
mod bench { mod bench {
use std::collections::TreeMap; use std::collections::BTreeMap;
use std::string; use std::string;
use serialize; use serialize;
use test::Bencher; use test::Bencher;
@ -1709,7 +1709,7 @@ mod bench {
macro_rules! treemap { macro_rules! treemap {
($($k:expr => $v:expr),*) => ({ ($($k:expr => $v:expr),*) => ({
let mut _m = ::std::collections::TreeMap::new(); let mut _m = ::std::collections::BTreeMap::new();
$(_m.insert($k, $v);)* $(_m.insert($k, $v);)*
_m _m
}) })
@ -1764,7 +1764,7 @@ mod bench {
)) ))
))); )));
} }
list.push(Json::Object(TreeMap::new())); list.push(Json::Object(BTreeMap::new()));
Json::Array(list) Json::Array(list)
} }
@ -1783,7 +1783,7 @@ mod bench {
)) ))
))); )));
} }
list.push(Value::Object(TreeMap::new())); list.push(Value::Object(BTreeMap::new()));
Value::Array(list) Value::Array(list)
} }

5
src/json/ser.rs
View File

@ -2,6 +2,7 @@ use std::f32;
use std::f64; use std::f64;
use std::num::{Float, FPNaN, FPInfinite}; use std::num::{Float, FPNaN, FPInfinite};
use std::io::{IoError, IoResult}; use std::io::{IoError, IoResult};
use std::str::Utf8Error;
use ser::Serialize; use ser::Serialize;
use ser; use ser;
@ -599,7 +600,7 @@ pub fn to_vec<
#[inline] #[inline]
pub fn to_string< pub fn to_string<
T: Serialize<Serializer<Vec<u8>>, IoError> T: Serialize<Serializer<Vec<u8>>, IoError>
>(value: &T) -> Result<String, Vec<u8>> { >(value: &T) -> Result<String, (Vec<u8>, Utf8Error)> {
let buf = to_vec(value); let buf = to_vec(value);
String::from_utf8(buf) String::from_utf8(buf)
} }
@ -628,7 +629,7 @@ pub fn to_pretty_vec<
/// Encode the specified struct into a json `String` buffer. /// Encode the specified struct into a json `String` buffer.
pub fn to_pretty_string< pub fn to_pretty_string<
T: Serialize<PrettySerializer<Vec<u8>>, IoError> T: Serialize<PrettySerializer<Vec<u8>>, IoError>
>(value: &T) -> Result<String, Vec<u8>> { >(value: &T) -> Result<String, (Vec<u8>, Utf8Error)> {
let buf = to_pretty_vec(value); let buf = to_pretty_vec(value);
String::from_utf8(buf) String::from_utf8(buf)
} }

22
src/json/value.rs
View File

@ -1,4 +1,4 @@
use std::collections::{HashMap, TreeMap, tree_map}; use std::collections::{HashMap, BTreeMap, btree_map};
use std::fmt; use std::fmt;
use std::io::{ByRefWriter, IoResult}; use std::io::{ByRefWriter, IoResult};
use std::io; use std::io;
@ -21,7 +21,7 @@ pub enum Value {
Floating(f64), Floating(f64),
String(String), String(String),
Array(Vec<Value>), Array(Vec<Value>),
Object(TreeMap<String, Value>), Object(BTreeMap<String, Value>),
} }
impl Value { impl Value {
@ -99,7 +99,7 @@ impl Value {
/// If the Json value is an Object, returns the associated TreeMap. /// If the Json value is an Object, returns the associated TreeMap.
/// Returns None otherwise. /// Returns None otherwise.
pub fn as_object<'a>(&'a self) -> Option<&'a TreeMap<String, Value>> { pub fn as_object<'a>(&'a self) -> Option<&'a BTreeMap<String, Value>> {
match *self { match *self {
Value::Object(ref map) => Some(map), Value::Object(ref map) => Some(map),
_ => None _ => None
@ -286,7 +286,7 @@ impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for Value {
Token::EnumStart(_, name, len) => { Token::EnumStart(_, name, len) => {
let token = Token::SeqStart(len); let token = Token::SeqStart(len);
let fields: Vec<Value> = try!(de::Deserialize::deserialize_token(d, token)); let fields: Vec<Value> = try!(de::Deserialize::deserialize_token(d, token));
let mut object = TreeMap::new(); let mut object = BTreeMap::new();
object.insert(name.to_string(), Value::Array(fields)); object.insert(name.to_string(), Value::Array(fields));
Ok(Value::Object(object)) Ok(Value::Object(object))
} }
@ -302,8 +302,8 @@ impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for Value {
enum State { enum State {
Value(Value), Value(Value),
Array(vec::MoveItems<Value>), Array(vec::IntoIter<Value>),
Object(tree_map::MoveEntries<String, Value>), Object(btree_map::IntoIter<String, Value>),
End, End,
} }
@ -584,7 +584,7 @@ impl ToJson for String {
} }
macro_rules! peel_to_json_tuple { macro_rules! peel_to_json_tuple {
($name:ident, $($other:ident,)*) => (impl_to_json_tuple!($($other,)*)) ($name:ident, $($other:ident,)*) => ( impl_to_json_tuple!($($other,)*); )
} }
macro_rules! impl_to_json_tuple { macro_rules! impl_to_json_tuple {
@ -615,7 +615,7 @@ macro_rules! impl_to_json_tuple {
Value::Array(array) Value::Array(array)
} }
} }
peel_to_json_tuple!($($name,)*) peel_to_json_tuple!($($name,)*);
} }
} }
@ -627,9 +627,9 @@ impl<A:ToJson> ToJson for Vec<A> {
} }
} }
impl<A:ToJson> ToJson for TreeMap<String, A> { impl<A:ToJson> ToJson for BTreeMap<String, A> {
fn to_json(&self) -> Value { fn to_json(&self) -> Value {
let mut d = TreeMap::new(); let mut d = BTreeMap::new();
for (key, value) in self.iter() { for (key, value) in self.iter() {
d.insert((*key).clone(), value.to_json()); d.insert((*key).clone(), value.to_json());
} }
@ -639,7 +639,7 @@ impl<A:ToJson> ToJson for TreeMap<String, A> {
impl<A:ToJson> ToJson for HashMap<String, A> { impl<A:ToJson> ToJson for HashMap<String, A> {
fn to_json(&self) -> Value { fn to_json(&self) -> Value {
let mut d = TreeMap::new(); let mut d = BTreeMap::new();
for (key, value) in self.iter() { for (key, value) in self.iter() {
d.insert((*key).clone(), value.to_json()); d.insert((*key).clone(), value.to_json());
} }

2
src/lib.rs
View File

@ -12,6 +12,8 @@ extern crate serde_macros;
#[cfg(test)] #[cfg(test)]
extern crate serialize; extern crate serialize;
extern crate unicode;
pub use de::{Deserializer, Deserialize}; pub use de::{Deserializer, Deserialize};
pub use ser::{Serializer, Serialize}; pub use ser::{Serializer, Serialize};

48
src/ser.rs
View File

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use std::collections::{HashMap, HashSet, TreeMap, TreeSet}; use std::collections::{HashMap, HashSet, BTreeMap, BTreeSet};
use std::hash::Hash; use std::hash::Hash;
use std::rc::Rc; use std::rc::Rc;
use std::sync::Arc; use std::sync::Arc;
@ -130,20 +130,20 @@ macro_rules! impl_serialize {
} }
} }
impl_serialize!(bool, serialize_bool) impl_serialize!(bool, serialize_bool);
impl_serialize!(int, serialize_int) impl_serialize!(int, serialize_int);
impl_serialize!(i8, serialize_i8) impl_serialize!(i8, serialize_i8);
impl_serialize!(i16, serialize_i16) impl_serialize!(i16, serialize_i16);
impl_serialize!(i32, serialize_i32) impl_serialize!(i32, serialize_i32);
impl_serialize!(i64, serialize_i64) impl_serialize!(i64, serialize_i64);
impl_serialize!(uint, serialize_uint) impl_serialize!(uint, serialize_uint);
impl_serialize!(u8, serialize_u8) impl_serialize!(u8, serialize_u8);
impl_serialize!(u16, serialize_u16) impl_serialize!(u16, serialize_u16);
impl_serialize!(u32, serialize_u32) impl_serialize!(u32, serialize_u32);
impl_serialize!(u64, serialize_u64) impl_serialize!(u64, serialize_u64);
impl_serialize!(f32, serialize_f32) impl_serialize!(f32, serialize_f32);
impl_serialize!(f64, serialize_f64) impl_serialize!(f64, serialize_f64);
impl_serialize!(char, serialize_char) impl_serialize!(char, serialize_char);
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
@ -179,9 +179,9 @@ macro_rules! impl_serialize_box {
} }
} }
impl_serialize_box!(&'a T) impl_serialize_box!(&'a T);
impl_serialize_box!(Box<T>) impl_serialize_box!(Box<T>);
impl_serialize_box!(Rc<T>) impl_serialize_box!(Rc<T>);
impl< impl<
S: Serializer<E>, S: Serializer<E>,
@ -239,7 +239,7 @@ impl<
E, E,
K: Serialize<S, E> + Ord, K: Serialize<S, E> + Ord,
V: Serialize<S, E> V: Serialize<S, E>
> Serialize<S, E> for TreeMap<K, V> { > Serialize<S, E> for BTreeMap<K, V> {
#[inline] #[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_map(self.iter()) s.serialize_map(self.iter())
@ -263,7 +263,7 @@ impl<
S: Serializer<E>, S: Serializer<E>,
E, E,
T: Serialize<S, E> + Ord T: Serialize<S, E> + Ord
> Serialize<S, E> for TreeSet<T> { > Serialize<S, E> for BTreeSet<T> {
#[inline] #[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> { fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_seq(self.iter()) s.serialize_seq(self.iter())
@ -273,7 +273,7 @@ impl<
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
macro_rules! peel { macro_rules! peel {
($name:ident, $($other:ident,)*) => (impl_serialize_tuple!($($other,)*)) ($name:ident, $($other:ident,)*) => ( impl_serialize_tuple!($($other,)*); )
} }
macro_rules! impl_serialize_tuple { macro_rules! impl_serialize_tuple {
@ -307,7 +307,7 @@ macro_rules! impl_serialize_tuple {
s.serialize_tuple_end() s.serialize_tuple_end()
} }
} }
peel!($($name,)*) peel!($($name,)*);
} }
} }
@ -317,7 +317,7 @@ impl_serialize_tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use std::collections::{HashMap, TreeMap}; use std::collections::{HashMap, BTreeMap};
use std::{option, string}; use std::{option, string};
@ -825,7 +825,7 @@ mod tests {
let mut serializer = AssertSerializer::new(tokens.into_iter()); let mut serializer = AssertSerializer::new(tokens.into_iter());
let mut map = TreeMap::new(); let mut map = BTreeMap::new();
map.insert(5i, "a".to_string()); map.insert(5i, "a".to_string());
map.insert(6i, "b".to_string()); map.insert(6i, "b".to_string());