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

Initial port of build_log

Browse Source
This commit is contained in:
Erick Tryzelaar 2015-01-18 10:05:13 -08:00
parent cc40b0ec5e
commit f7eb082339
5 changed files with 171 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

295
serde2/benches/bench_log.rs
View File

@ -34,19 +34,18 @@ enum HttpField {
RequestUri, RequestUri,
} }
impl< impl de::Deserialize for HttpField {
S: Deserializer<E>, fn deserialize<
E: de::Error, S: Deserializer,
> de::Deserialize<S, E> for HttpField { >(state: &mut S) -> Result<HttpField, S::Error> {
fn deserialize(state: &mut S) -> Result<HttpField, E> {
struct Visitor; struct Visitor;
impl< impl de::Visitor for Visitor {
'a, type Value = HttpField;
S: de::Deserializer<E>,
fn visit_str<
E: de::Error, E: de::Error,
> de::Visitor<S, HttpField, E> for Visitor { >(&mut self, value: &str) -> Result<HttpField, E> {
fn visit_str(&mut self, value: &str) -> Result<HttpField, E> {
let x = match value { let x = match value {
"protocol" => HttpField::Protocol, "protocol" => HttpField::Protocol,
"status" => HttpField::Status, "status" => HttpField::Status,
@ -68,7 +67,7 @@ impl<
} }
#[derive(Show, PartialEq, RustcEncodable, RustcDecodable)] #[derive(Show, PartialEq, RustcEncodable, RustcDecodable)]
#[derive_serialize] //#[derive_serialize]
//#[derive_deserialize] //#[derive_deserialize]
struct Http { struct Http {
protocol: HttpProtocol, protocol: HttpProtocol,
@ -81,20 +80,19 @@ struct Http {
referer: String, referer: String,
request_uri: String, request_uri: String,
} }
impl<
S: Deserializer<E>, impl de::Deserialize for Http {
E: de::Error, fn deserialize<
> de::Deserialize<S, E> for Http { S: Deserializer,
fn deserialize(state: &mut S) -> Result<Http, E> { >(state: &mut S) -> Result<Http, S::Error> {
struct Visitor; struct Visitor;
impl< impl de::Visitor for Visitor {
S: Deserializer<E>, type Value = Http;
E: de::Error,
> de::Visitor<S, Http, E> for Visitor {
fn visit_map< fn visit_map<
Visitor: de::MapVisitor<S, E>, V: de::MapVisitor,
>(&mut self, mut visitor: Visitor) -> Result<Http, E> { >(&mut self, mut visitor: V) -> Result<Http, V::Error> {
let mut protocol = None; let mut protocol = None;
let mut status = None; let mut status = None;
let mut host_status = None; let mut host_status = None;
@ -105,10 +103,8 @@ impl<
let mut referer = None; let mut referer = None;
let mut request_uri = None; let mut request_uri = None;
loop { while let Some(key) = try!(visitor.visit_key()) {
match try!(visitor.visit_key()) { match key {
Some(field) => {
match field {
HttpField::Protocol => { protocol = Some(try!(visitor.visit_value())); } HttpField::Protocol => { protocol = Some(try!(visitor.visit_value())); }
HttpField::Status => { status = Some(try!(visitor.visit_value())); } HttpField::Status => { status = Some(try!(visitor.visit_value())); }
HttpField::HostStatus => { host_status = Some(try!(visitor.visit_value())); } HttpField::HostStatus => { host_status = Some(try!(visitor.visit_value())); }
@ -120,9 +116,6 @@ impl<
HttpField::RequestUri => { request_uri = Some(try!(visitor.visit_value())); } HttpField::RequestUri => { request_uri = Some(try!(visitor.visit_value())); }
} }
} }
None => { break; }
}
}
Ok(Http { Ok(Http {
protocol: protocol.unwrap(), protocol: protocol.unwrap(),
@ -151,15 +144,15 @@ enum HttpProtocol {
impl rustc_serialize::Encodable for HttpProtocol { impl rustc_serialize::Encodable for HttpProtocol {
fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> { fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
(*self as uint).encode(s) (*self as u8).encode(s)
} }
} }
impl rustc_serialize::Decodable for HttpProtocol { impl rustc_serialize::Decodable for HttpProtocol {
fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<HttpProtocol, D::Error> { fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<HttpProtocol, D::Error> {
match FromPrimitive::from_uint(try!(d.read_usize())) { match FromPrimitive::from_u8(try!(d.read_u8())) {
Some(value) => Ok(value), Some(value) => Ok(value),
None => Err(d.error("cannot convert from uint")), None => Err(d.error("cannot convert from u8")),
} }
} }
} }
@ -167,22 +160,18 @@ impl rustc_serialize::Decodable for HttpProtocol {
impl ser::Serialize for HttpProtocol { impl ser::Serialize for HttpProtocol {
#[inline] #[inline]
fn visit< fn visit<
S, V: ser::Visitor,
R, >(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
E, visitor.visit_u8(*self as u8)
V: ser::Visitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
visitor.visit_uint(state, *self as uint)
} }
} }
impl< impl de::Deserialize for HttpProtocol {
S: de::Deserializer<E>,
E: de::Error,
> de::Deserialize<S, E> for HttpProtocol {
#[inline] #[inline]
fn deserialize(state: &mut S) -> Result<HttpProtocol, E> { fn deserialize<
de::deserialize_from_primitive(state) S: Deserializer,
>(state: &mut S) -> Result<HttpProtocol, S::Error> {
state.visit(&mut de::PrimitiveVisitor)
} }
} }
@ -203,15 +192,15 @@ enum HttpMethod {
impl rustc_serialize::Encodable for HttpMethod { impl rustc_serialize::Encodable for HttpMethod {
fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> { fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
(*self as uint).encode(s) (*self as u8).encode(s)
} }
} }
impl rustc_serialize::Decodable for HttpMethod { impl rustc_serialize::Decodable for HttpMethod {
fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<HttpMethod, D::Error> { fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<HttpMethod, D::Error> {
match FromPrimitive::from_uint(try!(d.read_usize())) { match FromPrimitive::from_u8(try!(d.read_u8())) {
Some(value) => Ok(value), Some(value) => Ok(value),
None => Err(d.error("cannot convert from uint")), None => Err(d.error("cannot convert from u8")),
} }
} }
} }
@ -219,22 +208,18 @@ impl rustc_serialize::Decodable for HttpMethod {
impl ser::Serialize for HttpMethod { impl ser::Serialize for HttpMethod {
#[inline] #[inline]
fn visit< fn visit<
S, V: ser::Visitor,
R, >(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
E, visitor.visit_u8(*self as u8)
V: ser::Visitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
visitor.visit_uint(state, *self as uint)
} }
} }
impl< impl de::Deserialize for HttpMethod {
S: de::Deserializer<E>,
E: de::Error,
> de::Deserialize<S, E> for HttpMethod {
#[inline] #[inline]
fn deserialize(state: &mut S) -> Result<HttpMethod, E> { fn deserialize<
de::deserialize_from_primitive(state) S: de::Deserializer,
>(state: &mut S) -> Result<HttpMethod, S::Error> {
state.visit(&mut de::PrimitiveVisitor)
} }
} }
@ -248,13 +233,13 @@ enum CacheStatus {
impl rustc_serialize::Encodable for CacheStatus { impl rustc_serialize::Encodable for CacheStatus {
fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> { fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
(*self as uint).encode(s) (*self as u8).encode(s)
} }
} }
impl rustc_serialize::Decodable for CacheStatus { impl rustc_serialize::Decodable for CacheStatus {
fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<CacheStatus, D::Error> { fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<CacheStatus, D::Error> {
match FromPrimitive::from_uint(try!(d.read_usize())) { match FromPrimitive::from_u8(try!(d.read_u8())) {
Some(value) => Ok(value), Some(value) => Ok(value),
None => Err(d.error("cannot convert from uint")), None => Err(d.error("cannot convert from uint")),
} }
@ -264,19 +249,18 @@ impl rustc_serialize::Decodable for CacheStatus {
impl ser::Serialize for CacheStatus { impl ser::Serialize for CacheStatus {
#[inline] #[inline]
fn visit< fn visit<
S, V: ser::Visitor,
R, >(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
E, visitor.visit_u8(*self as u8)
V: ser::Visitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
visitor.visit_uint(state, *self as uint)
} }
} }
impl<S: de::Deserializer<E>, E: de::Error> de::Deserialize<S, E> for CacheStatus { impl de::Deserialize for CacheStatus {
#[inline] #[inline]
fn deserialize(state: &mut S) -> Result<CacheStatus, E> { fn deserialize<
de::deserialize_from_primitive(state) S: de::Deserializer,
>(state: &mut S) -> Result<CacheStatus, S::Error> {
state.visit(&mut de::PrimitiveVisitor)
} }
} }
@ -287,19 +271,18 @@ enum OriginField {
Protocol, Protocol,
} }
impl< impl de::Deserialize for OriginField {
S: Deserializer<E>, fn deserialize<
E: de::Error, S: Deserializer,
> de::Deserialize<S, E> for OriginField { >(state: &mut S) -> Result<OriginField, S::Error> {
fn deserialize(state: &mut S) -> Result<OriginField, E> {
struct Visitor; struct Visitor;
impl< impl de::Visitor for Visitor {
'a, type Value = OriginField;
S: de::Deserializer<E>,
fn visit_str<
E: de::Error, E: de::Error,
> de::Visitor<S, OriginField, E> for Visitor { >(&mut self, value: &str) -> Result<OriginField, E> {
fn visit_str(&mut self, value: &str) -> Result<OriginField, E> {
let x = match value { let x = match value {
"ip" => OriginField::Ip, "ip" => OriginField::Ip,
"port" => OriginField::Port, "port" => OriginField::Port,
@ -316,7 +299,7 @@ impl<
} }
#[derive(Show, PartialEq, RustcEncodable, RustcDecodable)] #[derive(Show, PartialEq, RustcEncodable, RustcDecodable)]
#[derive_serialize] //#[derive_serialize]
//#[derive_deserialize] //#[derive_deserialize]
struct Origin { struct Origin {
ip: String, ip: String,
@ -325,38 +308,31 @@ struct Origin {
protocol: OriginProtocol, protocol: OriginProtocol,
} }
impl< impl Deserialize for Origin {
S: Deserializer<E>, fn deserialize<
E: de::Error, S: de::Deserializer,
> Deserialize<S, E> for Origin { >(state: &mut S) -> Result<Origin, S::Error> {
fn deserialize(state: &mut S) -> Result<Origin, E> {
struct Visitor; struct Visitor;
impl< impl de::Visitor for Visitor {
S: Deserializer<E>, type Value = Origin;
E: de::Error,
> de::Visitor<S, Origin, E> for Visitor {
fn visit_map< fn visit_map<
Visitor: de::MapVisitor<S, E>, V: de::MapVisitor,
>(&mut self, mut visitor: Visitor) -> Result<Origin, E> { >(&mut self, mut visitor: V) -> Result<Origin, V::Error> {
let mut ip = None; let mut ip = None;
let mut port = None; let mut port = None;
let mut hostname = None; let mut hostname = None;
let mut protocol = None; let mut protocol = None;
loop { while let Some(key) = try!(visitor.visit_key()) {
match try!(visitor.visit_key()) { match key {
Some(field) => {
match field {
OriginField::Ip => { ip = Some(try!(visitor.visit_value())); } OriginField::Ip => { ip = Some(try!(visitor.visit_value())); }
OriginField::Port => { port = Some(try!(visitor.visit_value())); } OriginField::Port => { port = Some(try!(visitor.visit_value())); }
OriginField::Hostname => { hostname = Some(try!(visitor.visit_value())); } OriginField::Hostname => { hostname = Some(try!(visitor.visit_value())); }
OriginField::Protocol => { protocol = Some(try!(visitor.visit_value())); } OriginField::Protocol => { protocol = Some(try!(visitor.visit_value())); }
} }
} }
None => { break; }
}
}
Ok(Origin { Ok(Origin {
ip: ip.unwrap(), ip: ip.unwrap(),
@ -380,15 +356,15 @@ enum OriginProtocol {
impl rustc_serialize::Encodable for OriginProtocol { impl rustc_serialize::Encodable for OriginProtocol {
fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> { fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
(*self as uint).encode(s) (*self as u8).encode(s)
} }
} }
impl rustc_serialize::Decodable for OriginProtocol { impl rustc_serialize::Decodable for OriginProtocol {
fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<OriginProtocol, D::Error> { fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<OriginProtocol, D::Error> {
match FromPrimitive::from_uint(try!(d.read_usize())) { match FromPrimitive::from_u8(try!(d.read_u8())) {
Some(value) => Ok(value), Some(value) => Ok(value),
None => Err(d.error("cannot convert from uint")), None => Err(d.error("cannot convert from u8")),
} }
} }
} }
@ -396,19 +372,18 @@ impl rustc_serialize::Decodable for OriginProtocol {
impl ser::Serialize for OriginProtocol { impl ser::Serialize for OriginProtocol {
#[inline] #[inline]
fn visit< fn visit<
S, V: ser::Visitor,
R, >(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
E, visitor.visit_u8(*self as u8)
V: ser::Visitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
visitor.visit_uint(state, *self as uint)
} }
} }
impl<S: de::Deserializer<E>, E: de::Error> de::Deserialize<S, E> for OriginProtocol { impl de::Deserialize for OriginProtocol {
#[inline] #[inline]
fn deserialize(state: &mut S) -> Result<OriginProtocol, E> { fn deserialize<
de::deserialize_from_primitive(state) S: de::Deserializer,
>(state: &mut S) -> Result<OriginProtocol, S::Error> {
state.visit(&mut de::PrimitiveVisitor)
} }
} }
@ -423,15 +398,15 @@ enum ZonePlan {
impl rustc_serialize::Encodable for ZonePlan { impl rustc_serialize::Encodable for ZonePlan {
fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> { fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
(*self as uint).encode(s) (*self as u8).encode(s)
} }
} }
impl rustc_serialize::Decodable for ZonePlan { impl rustc_serialize::Decodable for ZonePlan {
fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<ZonePlan, D::Error> { fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<ZonePlan, D::Error> {
match FromPrimitive::from_uint(try!(d.read_usize())) { match FromPrimitive::from_u8(try!(d.read_u8())) {
Some(value) => Ok(value), Some(value) => Ok(value),
None => Err(d.error("cannot convert from uint")), None => Err(d.error("cannot convert from u8")),
} }
} }
} }
@ -439,19 +414,18 @@ impl rustc_serialize::Decodable for ZonePlan {
impl ser::Serialize for ZonePlan { impl ser::Serialize for ZonePlan {
#[inline] #[inline]
fn visit< fn visit<
S, V: ser::Visitor,
R, >(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
E, visitor.visit_u8(*self as u8)
V: ser::Visitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
visitor.visit_uint(state, *self as uint)
} }
} }
impl<S: de::Deserializer<E>, E: de::Error> de::Deserialize<S, E> for ZonePlan { impl de::Deserialize for ZonePlan {
#[inline] #[inline]
fn deserialize(state: &mut S) -> Result<ZonePlan, E> { fn deserialize<
de::deserialize_from_primitive(state) S: de::Deserializer,
>(state: &mut S) -> Result<ZonePlan, S::Error> {
state.visit(&mut de::PrimitiveVisitor)
} }
} }
@ -717,15 +691,15 @@ enum Country {
impl rustc_serialize::Encodable for Country { impl rustc_serialize::Encodable for Country {
fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> { fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
(*self as uint).encode(s) (*self as u8).encode(s)
} }
} }
impl rustc_serialize::Decodable for Country { impl rustc_serialize::Decodable for Country {
fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<Country, D::Error> { fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<Country, D::Error> {
match FromPrimitive::from_uint(try!(d.read_usize())) { match FromPrimitive::from_u8(try!(d.read_u8())) {
Some(value) => Ok(value), Some(value) => Ok(value),
None => Err(d.error("cannot convert from uint")), None => Err(d.error("cannot convert from u8")),
} }
} }
} }
@ -733,19 +707,18 @@ impl rustc_serialize::Decodable for Country {
impl ser::Serialize for Country { impl ser::Serialize for Country {
#[inline] #[inline]
fn visit< fn visit<
S, V: ser::Visitor,
R, >(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
E, visitor.visit_u8(*self as u8)
V: ser::Visitor<S, R, E>,
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
visitor.visit_uint(state, *self as uint)
} }
} }
impl<S: de::Deserializer<E>, E: de::Error> de::Deserialize<S, E> for Country { impl de::Deserialize for Country {
#[inline] #[inline]
fn deserialize(state: &mut S) -> Result<Country, E> { fn deserialize<
de::deserialize_from_primitive(state) S: de::Deserializer,
>(state: &mut S) -> Result<Country, S::Error> {
state.visit(&mut de::PrimitiveVisitor)
} }
} }
@ -764,19 +737,18 @@ enum LogField {
RayId, RayId,
} }
impl< impl de::Deserialize for LogField {
S: Deserializer<E>, fn deserialize<
E: de::Error, S: de::Deserializer,
> de::Deserialize<S, E> for LogField { >(state: &mut S) -> Result<LogField, S::Error> {
fn deserialize(state: &mut S) -> Result<LogField, E> {
struct Visitor; struct Visitor;
impl< impl de::Visitor for Visitor {
'a, type Value = LogField;
S: de::Deserializer<E>,
fn visit_str<
E: de::Error, E: de::Error,
> de::Visitor<S, LogField, E> for Visitor { >(&mut self, value: &str) -> Result<LogField, E> {
fn visit_str(&mut self, value: &str) -> Result<LogField, E> {
let x = match value { let x = match value {
"timestamp" => LogField::Timestamp, "timestamp" => LogField::Timestamp,
"zone_id" => LogField::ZoneId, "zone_id" => LogField::ZoneId,
@ -801,7 +773,7 @@ impl<
} }
#[derive(Show, PartialEq, RustcEncodable, RustcDecodable)] #[derive(Show, PartialEq, RustcEncodable, RustcDecodable)]
#[derive_serialize] //#[derive_serialize]
//#[derive_deserialize] //#[derive_deserialize]
struct Log { struct Log {
timestamp: i64, timestamp: i64,
@ -818,20 +790,18 @@ struct Log {
ray_id: String, ray_id: String,
} }
impl< impl Deserialize for Log {
S: Deserializer<E>, fn deserialize<
E: de::Error, S: de::Deserializer,
> Deserialize<S, E> for Log { >(state: &mut S) -> Result<Log, S::Error> {
fn deserialize(state: &mut S) -> Result<Log, E> {
struct Visitor; struct Visitor;
impl< impl de::Visitor for Visitor {
S: Deserializer<E>, type Value = Log;
E: de::Error,
> de::Visitor<S, Log, E> for Visitor {
fn visit_map< fn visit_map<
Visitor: de::MapVisitor<S, E>, V: de::MapVisitor,
>(&mut self, mut visitor: Visitor) -> Result<Log, E> { >(&mut self, mut visitor: V) -> Result<Log, V::Error> {
let mut timestamp = None; let mut timestamp = None;
let mut zone_id = None; let mut zone_id = None;
let mut zone_plan = None; let mut zone_plan = None;
@ -845,10 +815,8 @@ impl<
let mut bytes_dlv = None; let mut bytes_dlv = None;
let mut ray_id = None; let mut ray_id = None;
loop { while let Some(key) = try!(visitor.visit_key()) {
match try!(visitor.visit_key()) { match key {
Some(field) => {
match field {
LogField::Timestamp => { timestamp = Some(try!(visitor.visit_value())); } LogField::Timestamp => { timestamp = Some(try!(visitor.visit_value())); }
LogField::ZoneId => { zone_id = Some(try!(visitor.visit_value())); } LogField::ZoneId => { zone_id = Some(try!(visitor.visit_value())); }
LogField::ZonePlan => { zone_plan = Some(try!(visitor.visit_value())); } LogField::ZonePlan => { zone_plan = Some(try!(visitor.visit_value())); }
@ -863,9 +831,6 @@ impl<
LogField::RayId => { ray_id = Some(try!(visitor.visit_value())); } LogField::RayId => { ray_id = Some(try!(visitor.visit_value())); }
} }
} }
None => { break; }
}
}
Ok(Log { Ok(Log {
timestamp: timestamp.unwrap(), timestamp: timestamp.unwrap(),
@ -922,6 +887,7 @@ impl Log {
} }
} }
/*
macro_rules! likely( macro_rules! likely(
($val:expr) => { ($val:expr) => {
{ {
@ -1511,3 +1477,4 @@ fn bench_deserializer(b: &mut Bencher) {
let _log: Log = json::from_str(JSON_STR).unwrap(); let _log: Log = json::from_str(JSON_STR).unwrap();
}); });
} }
*/

2
serde2/src/de.rs
View File

@ -351,7 +351,7 @@ macro_rules! impl_deserialize_num_method {
} }
} }
struct PrimitiveVisitor<T>; pub struct PrimitiveVisitor<T>;
impl< impl<
T: Deserialize + FromPrimitive T: Deserialize + FromPrimitive

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

@ -96,22 +96,22 @@ mod tests {
assert_eq!(value, Value::Array(Vec::new())); assert_eq!(value, Value::Array(Vec::new()));
let value = ArrayBuilder::new() let value = ArrayBuilder::new()
.push(1i) .push(1)
.push(2i) .push(2)
.push(3i) .push(3)
.unwrap(); .unwrap();
assert_eq!(value, Value::Array(vec!(Value::I64(1), Value::I64(2), Value::I64(3)))); assert_eq!(value, Value::Array(vec!(Value::I64(1), Value::I64(2), Value::I64(3))));
let value = ArrayBuilder::new() let value = ArrayBuilder::new()
.push_array(|bld| bld.push(1i).push(2i).push(3i)) .push_array(|bld| bld.push(1).push(2).push(3))
.unwrap(); .unwrap();
assert_eq!(value, Value::Array(vec!(Value::Array(vec!(Value::I64(1), Value::I64(2), Value::I64(3)))))); assert_eq!(value, Value::Array(vec!(Value::Array(vec!(Value::I64(1), Value::I64(2), Value::I64(3))))));
let value = ArrayBuilder::new() let value = ArrayBuilder::new()
.push_object(|bld| .push_object(|bld|
bld bld
.insert("a".to_string(), 1i) .insert("a".to_string(), 1)
.insert("b".to_string(), 2i)) .insert("b".to_string(), 2))
.unwrap(); .unwrap();
let mut map = BTreeMap::new(); let mut map = BTreeMap::new();
@ -126,8 +126,8 @@ mod tests {
assert_eq!(value, Value::Object(BTreeMap::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(), 1)
.insert("b".to_string(), 2i) .insert("b".to_string(), 2)
.unwrap(); .unwrap();
let mut map = BTreeMap::new(); let mut map = BTreeMap::new();

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

@ -679,15 +679,15 @@ mod tests {
]); ]);
test_parse_ok(vec![ test_parse_ok(vec![
("[1]", (1u,)), ("[1]", (1,)),
]); ]);
test_parse_ok(vec![ test_parse_ok(vec![
("[1, 2]", (1u, 2u)), ("[1, 2]", (1, 2)),
]); ]);
test_parse_ok(vec![ test_parse_ok(vec![
("[1, 2, 3]", (1u, 2u, 3u)), ("[1, 2, 3]", (1, 2, 3)),
]); ]);
} }

2
serde2/src/json/mod.rs
View File

@ -1,10 +1,8 @@
/*
pub use self::ser::Writer; pub use self::ser::Writer;
pub use self::ser::{to_vec, to_string}; pub use self::ser::{to_vec, to_string};
pub use self::ser::escape_str; pub use self::ser::escape_str;
pub use self::de::from_str; pub use self::de::from_str;
*/
pub mod builder; pub mod builder;
pub mod de; pub mod de;