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

Rename Serializable to Serialize, Deserializable to Deserialize

Browse Source
This commit is contained in:
Erick Tryzelaar
2014-11-13 07:54:44 -08:00
parent 45247c7ef6
commit 21a58e86e4
11 changed files with 297 additions and 297 deletions
Download Patch File Download Diff File Expand all files Collapse all files
benches/bench_enum.rs
+5 -5
View File
@@ -11,12 +11,12 @@ use test::Bencher;
use serialize::{Decoder, Decodable};
use serde::de::{Deserializer, Deserializable};
use serde::de::{Deserializer, Deserialize};
//////////////////////////////////////////////////////////////////////////////
#[deriving(Clone, PartialEq, Show, Decodable)]
#[deriving_deserializable]
#[deriving_deserialize]
enum Animal {
Dog,
Frog(String, int)
@@ -260,7 +260,7 @@ mod deserializer {
#[inline]
fn missing_field<
T: de::Deserializable<AnimalDeserializer, Error>
T: de::Deserialize<AnimalDeserializer, Error>
>(&mut self, _field: &'static str) -> Result<T, Error> {
Err(SyntaxError)
}
@@ -299,7 +299,7 @@ fn bench_deserializer_dog(b: &mut Bencher) {
let animal = Dog;
let mut d = deserializer::AnimalDeserializer::new(animal.clone());
let value: Animal = Deserializable::deserialize(&mut d).unwrap();
let value: Animal = Deserialize::deserialize(&mut d).unwrap();
assert_eq!(value, animal);
})
@@ -311,7 +311,7 @@ fn bench_deserializer_frog(b: &mut Bencher) {
let animal = Frog("Henry".to_string(), 349);
let mut d = deserializer::AnimalDeserializer::new(animal.clone());
let value: Animal = Deserializable::deserialize(&mut d).unwrap();
let value: Animal = Deserialize::deserialize(&mut d).unwrap();
assert_eq!(value, animal);
})
benches/bench_log.rs
+19 -19
View File
@@ -14,12 +14,12 @@ use test::Bencher;
use serde::de;
use serde::json;
use serde::ser::Serializable;
use serde::ser::Serialize;
use serde::ser;
#[deriving(Encodable, Decodable)]
#[deriving_serializable]
#[deriving_deserializable]
#[deriving_serialize]
#[deriving_deserialize]
struct Http {
protocol: HttpProtocol,
status: u32,
@@ -39,14 +39,14 @@ enum HttpProtocol {
HTTP11,
}
impl<S: ser::Serializer<E>, E> ser::Serializable<S, E> for HttpProtocol {
impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for HttpProtocol {
#[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_uint(*self as uint)
}
}
impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for HttpProtocol {
impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for HttpProtocol {
#[inline]
fn deserialize_token(d: &mut D, token: de::Token) -> Result<HttpProtocol, E> {
d.expect_from_primitive(token)
@@ -68,14 +68,14 @@ enum HttpMethod {
PATCH,
}
impl<S: ser::Serializer<E>, E> ser::Serializable<S, E> for HttpMethod {
impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for HttpMethod {
#[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_uint(*self as uint)
}
}
impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for HttpMethod {
impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for HttpMethod {
#[inline]
fn deserialize_token(d: &mut D, token: de::Token) -> Result<HttpMethod, E> {
d.expect_from_primitive(token)
@@ -90,14 +90,14 @@ enum CacheStatus {
Hit,
}
impl<S: ser::Serializer<E>, E> ser::Serializable<S, E> for CacheStatus {
impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for CacheStatus {
#[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_uint(*self as uint)
}
}
impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for CacheStatus {
impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for CacheStatus {
#[inline]
fn deserialize_token(d: &mut D, token: de::Token) -> Result<CacheStatus, E> {
d.expect_from_primitive(token)
@@ -105,8 +105,8 @@ impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for CacheStatus {
}
#[deriving(Encodable, Decodable)]
#[deriving_serializable]
#[deriving_deserializable]
#[deriving_serialize]
#[deriving_deserialize]
struct Origin {
ip: String,
port: u32,
@@ -121,14 +121,14 @@ enum OriginProtocol {
HTTPS,
}
impl<S: ser::Serializer<E>, E> ser::Serializable<S, E> for OriginProtocol {
impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for OriginProtocol {
#[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_uint(*self as uint)
}
}
impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for OriginProtocol {
impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for OriginProtocol {
#[inline]
fn deserialize_token(d: &mut D, token: de::Token) -> Result<OriginProtocol, E> {
d.expect_from_primitive(token)
@@ -144,14 +144,14 @@ enum ZonePlan {
ENT,
}
impl<S: ser::Serializer<E>, E> ser::Serializable<S, E> for ZonePlan {
impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for ZonePlan {
#[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_uint(*self as uint)
}
}
impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for ZonePlan {
impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for ZonePlan {
#[inline]
fn deserialize_token(d: &mut D, token: de::Token) -> Result<ZonePlan, E> {
d.expect_from_primitive(token)
@@ -418,14 +418,14 @@ enum Country {
ZW,
}
impl<S: ser::Serializer<E>, E> ser::Serializable<S, E> for Country {
impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for Country {
#[inline]
fn serialize(&self, s: &mut S) -> Result<(), E> {
s.serialize_uint(*self as uint)
}
}
impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for Country {
impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for Country {
#[inline]
fn deserialize_token(d: &mut D, token: de::Token) -> Result<Country, E> {
d.expect_from_primitive(token)
@@ -433,8 +433,8 @@ impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for Country {
}
#[deriving(Encodable, Decodable)]
#[deriving_serializable]
#[deriving_deserializable]
#[deriving_serialize]
#[deriving_deserialize]
struct Log {
timestamp: i64,
zone_id: u32,
benches/bench_map.rs
+4 -4
View File
@@ -13,7 +13,7 @@ use test::Bencher;
use serialize::{Decoder, Decodable};
use serde::de::{Deserializer, Deserializable};
use serde::de::{Deserializer, Deserialize};
//////////////////////////////////////////////////////////////////////////////
@@ -258,7 +258,7 @@ mod deserializer {
#[inline]
fn missing_field<
T: de::Deserializable<IntDeserializer, Error>
T: de::Deserialize<IntDeserializer, Error>
>(&mut self, _field: &'static str) -> Result<T, Error> {
Err(SyntaxError)
}
@@ -310,9 +310,9 @@ fn bench_decoder_100(b: &mut Bencher) {
fn run_deserializer<
D: Deserializer<E>,
E: Show,
T: Clone + PartialEq + Show + Deserializable<D, E>
T: Clone + PartialEq + Show + Deserialize<D, E>
>(mut d: D, value: T) {
let v: T = Deserializable::deserialize(&mut d).unwrap();
let v: T = Deserialize::deserialize(&mut d).unwrap();
assert_eq!(value, v);
}
benches/bench_struct.rs
+7 -7
View File
@@ -12,12 +12,12 @@ use test::Bencher;
use serialize::{Decoder, Decodable};
use serde::de::{Deserializer, Deserializable};
use serde::de::{Deserializer, Deserialize};
//////////////////////////////////////////////////////////////////////////////
#[deriving(Clone, PartialEq, Show, Decodable)]
#[deriving_deserializable]
#[deriving_deserialize]
struct Inner {
a: (),
b: uint,
@@ -27,7 +27,7 @@ struct Inner {
//////////////////////////////////////////////////////////////////////////////
#[deriving(Clone, PartialEq, Show, Decodable)]
#[deriving_deserializable]
#[deriving_deserialize]
struct Outer {
inner: Vec<Inner>,
}
@@ -387,7 +387,7 @@ mod deserializer {
#[inline]
fn missing_field<
T: de::Deserializable<OuterDeserializer, Error>
T: de::Deserialize<OuterDeserializer, Error>
>(&mut self, field: &'static str) -> Result<T, Error> {
Err(MissingField(field))
}
@@ -468,7 +468,7 @@ fn bench_deserializer_0_0(b: &mut Bencher) {
};
let mut d = deserializer::OuterDeserializer::new(outer.clone());
let value: Outer = Deserializable::deserialize(&mut d).unwrap();
let value: Outer = Deserialize::deserialize(&mut d).unwrap();
assert_eq!(value, outer);
})
@@ -490,7 +490,7 @@ fn bench_deserializer_1_0(b: &mut Bencher) {
};
let mut d = deserializer::OuterDeserializer::new(outer.clone());
let value: Outer = Deserializable::deserialize(&mut d).unwrap();
let value: Outer = Deserialize::deserialize(&mut d).unwrap();
assert_eq!(value, outer);
})
@@ -517,7 +517,7 @@ fn bench_deserializer_1_5(b: &mut Bencher) {
};
let mut d = deserializer::OuterDeserializer::new(outer.clone());
let value: Outer = Deserializable::deserialize(&mut d).unwrap();
let value: Outer = Deserialize::deserialize(&mut d).unwrap();
assert_eq!(value, outer);
})
benches/bench_vec.rs
+5 -5
View File
@@ -12,7 +12,7 @@ use test::Bencher;
use serialize::{Decoder, Decodable};
use serde::de::{Deserializer, Deserializable};
use serde::de::{Deserializer, Deserialize};
//////////////////////////////////////////////////////////////////////////////
@@ -327,7 +327,7 @@ mod deserializer {
#[inline]
fn missing_field<
T: de::Deserializable<IntDeserializer, Error>
T: de::Deserialize<IntDeserializer, Error>
>(&mut self, _field: &'static str) -> Result<T, Error> {
Err(SyntaxError)
}
@@ -399,7 +399,7 @@ mod deserializer {
#[inline]
fn missing_field<
T: de::Deserializable<U8Deserializer, Error>
T: de::Deserialize<U8Deserializer, Error>
>(&mut self, _field: &'static str) -> Result<T, Error> {
Err(SyntaxError)
}
@@ -421,9 +421,9 @@ fn run_decoder<
fn run_deserializer<
D: Deserializer<E>,
E: Show,
T: Clone + PartialEq + Show + Deserializable<D, E>
T: Clone + PartialEq + Show + Deserialize<D, E>
>(mut d: D, value: T) {
let v: T = Deserializable::deserialize(&mut d).unwrap();
let v: T = Deserialize::deserialize(&mut d).unwrap();
assert_eq!(value, v);
}