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

More cleanup of serde2

Browse Source
This commit is contained in:
Erick Tryzelaar 2014-09-02 07:39:02 -07:00
parent 9fe405319e
commit 8e4684bfef
5 changed files with 139 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
serde2/Cargo.lock generated
View File

@ -1,4 +1,11 @@
[root]
name = "serde2"
version = "0.1.0"
dependencies = [
"serde2_macros 0.1.0",
]
[[package]]
name = "serde2_macros"
version = "0.1.0"

3
serde2/Cargo.toml
View File

@ -9,3 +9,6 @@ name = "serde2"
[[bin]]
name = "serde2"
path = "src/bin.rs"
[dependencies.serde2_macros]
path = "serde2_macros/"

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

@ -12,6 +12,7 @@ pub struct Serializer<W> {
impl<W: Writer> Serializer<W> {
/// Creates a new JSON serializer whose output will be written to the writer
/// specified.
#[inline]
pub fn new(writer: W) -> Serializer<W> {
Serializer {
writer: writer,
@ -19,6 +20,7 @@ impl<W: Writer> Serializer<W> {
}
/// Unwrap the Writer from the Serializer.
#[inline]
pub fn unwrap(self) -> W {
self.writer
}
@ -39,11 +41,51 @@ impl<W: Writer> ser::VisitorState<io::IoResult<()>> for Serializer<W> {
}
}
#[inline]
fn visit_int(&mut self, value: int) -> io::IoResult<()> {
write!(self.writer, "{}", value)
}
#[inline]
fn visit_i8(&mut self, value: i8) -> io::IoResult<()> {
write!(self.writer, "{}", value)
}
#[inline]
fn visit_i16(&mut self, value: i16) -> io::IoResult<()> {
write!(self.writer, "{}", value)
}
#[inline]
fn visit_i32(&mut self, value: i32) -> io::IoResult<()> {
write!(self.writer, "{}", value)
}
#[inline]
fn visit_i64(&mut self, value: i64) -> io::IoResult<()> {
write!(self.writer, "{}", value)
}
#[inline]
fn visit_uint(&mut self, value: uint) -> io::IoResult<()> {
write!(self.writer, "{}", value)
}
#[inline]
fn visit_u8(&mut self, value: u8) -> io::IoResult<()> {
write!(self.writer, "{}", value)
}
#[inline]
fn visit_u16(&mut self, value: u16) -> io::IoResult<()> {
write!(self.writer, "{}", value)
}
#[inline]
fn visit_u32(&mut self, value: u32) -> io::IoResult<()> {
write!(self.writer, "{}", value)
}
#[inline]
fn visit_u64(&mut self, value: u64) -> io::IoResult<()> {
write!(self.writer, "{}", value)
@ -60,10 +102,11 @@ impl<W: Writer> ser::VisitorState<io::IoResult<()>> for Serializer<W> {
}
#[inline]
fn visit_str(&mut self, value: &'static str) -> io::IoResult<()> {
fn visit_str(&mut self, value: &str) -> io::IoResult<()> {
escape_str(&mut self.writer, value)
}
#[inline]
fn visit_seq<
V: ser::Visitor<Serializer<W>, io::IoResult<()>>
>(&mut self, mut visitor: V) -> io::IoResult<()> {
@ -76,19 +119,22 @@ impl<W: Writer> ser::VisitorState<io::IoResult<()>> for Serializer<W> {
None => { break; }
}
}
write!(self.writer, "]")
}
#[inline]
fn visit_seq_elt<
T: ser::Serialize<Serializer<W>, io::IoResult<()>>
>(&mut self, first: bool, value: T) -> io::IoResult<()> {
if !first {
try!(write!(self.writer, ", "));
try!(write!(self.writer, ","));
}
value.serialize(self)
//value.serialize(self)
}
#[inline]
fn visit_map<
V: ser::Visitor<Serializer<W>, io::IoResult<()>>
>(&mut self, mut visitor: V) -> io::IoResult<()> {
@ -104,21 +150,22 @@ impl<W: Writer> ser::VisitorState<io::IoResult<()>> for Serializer<W> {
write!(self.writer, "}}")
}
#[inline]
fn visit_map_elt<
K: ser::Serialize<Serializer<W>, io::IoResult<()>>,
V: ser::Serialize<Serializer<W>, io::IoResult<()>>
>(&mut self, first: bool, key: K, value: V) -> io::IoResult<()> {
if !first {
try!(write!(self.writer, ", "));
try!(write!(self.writer, ","));
}
try!(key.serialize(self));
try!(write!(self.writer, ": "));
try!(write!(self.writer, ":"));
value.serialize(self)
}
}
pub fn escape_bytes<W: Writer>(wr: &mut W, bytes: &[u8]) -> io::IoResult<()> {
fn escape_bytes<W: Writer>(wr: &mut W, bytes: &[u8]) -> io::IoResult<()> {
try!(wr.write_str("\""));
let mut start = 0;
@ -151,7 +198,7 @@ pub fn escape_bytes<W: Writer>(wr: &mut W, bytes: &[u8]) -> io::IoResult<()> {
wr.write_str("\"")
}
pub fn escape_str<W: Writer>(wr: &mut W, value: &str) -> io::IoResult<()> {
fn escape_str<W: Writer>(wr: &mut W, value: &str) -> io::IoResult<()> {
escape_bytes(wr, value.as_bytes())
}
@ -168,6 +215,7 @@ fn fmt_f64_or_null<W: Writer>(wr: &mut W, value: f64) -> io::IoResult<()> {
}
}
#[inline]
pub fn to_vec<
T: ser::Serialize<Serializer<io::MemWriter>, io::IoResult<()>>
>(value: &T) -> io::IoResult<Vec<u8>> {
@ -177,6 +225,7 @@ pub fn to_vec<
Ok(state.unwrap().unwrap())
}
#[inline]
pub fn to_string<
T: ser::Serialize<Serializer<io::MemWriter>, io::IoResult<()>>
>(value: &T) -> io::IoResult<Result<String, Vec<u8>>> {

2
serde2/src/lib.rs
View File

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

102
serde2/src/ser.rs
View File

@ -82,7 +82,7 @@ pub trait VisitorState<R> {
fn visit_char(&mut self, value: char) -> R;
fn visit_str(&mut self, value: &'static str) -> R;
fn visit_str(&mut self, value: &str) -> R;
fn visit_seq<
V: Visitor<Self, R>
@ -125,15 +125,45 @@ pub trait VisitorState<R> {
///////////////////////////////////////////////////////////////////////////////
impl<S: VisitorState<R>, R> Serialize<S, R> for int {
fn serialize(&self, state: &mut S) -> R {
state.visit_int(*self)
macro_rules! impl_serialize {
($ty:ty, $method:ident) => {
impl<S: VisitorState<R>, R> Serialize<S, R> for $ty {
#[inline]
fn serialize(&self, state: &mut S) -> R {
state.$method(*self)
}
}
}
}
impl<S: VisitorState<R>, R> Serialize<S, R> for &'static str {
fn serialize(&self, state: &mut S) -> R {
state.visit_str(*self)
impl_serialize!(bool, visit_bool)
impl_serialize!(int, visit_int)
impl_serialize!(i8, visit_i8)
impl_serialize!(i16, visit_i16)
impl_serialize!(i32, visit_i32)
impl_serialize!(i64, visit_i64)
impl_serialize!(uint, visit_uint)
impl_serialize!(u8, visit_u8)
impl_serialize!(u16, visit_u16)
impl_serialize!(u32, visit_u32)
impl_serialize!(u64, visit_u64)
impl_serialize!(f32, visit_f32)
impl_serialize!(f64, visit_f64)
impl_serialize!(char, visit_char)
///////////////////////////////////////////////////////////////////////////////
impl<'a, S: VisitorState<R>, R> Serialize<S, R> for &'a str {
#[inline]
fn serialize(&self, s: &mut S) -> R {
s.visit_str(*self)
}
}
impl<S: VisitorState<R>, R> Serialize<S, R> for String {
#[inline]
fn serialize(&self, s: &mut S) -> R {
s.visit_str(self.as_slice())
}
}
@ -145,6 +175,7 @@ pub struct SeqIteratorVisitor<Iter> {
}
impl<T, Iter: Iterator<T>> SeqIteratorVisitor<Iter> {
#[inline]
pub fn new(iter: Iter) -> SeqIteratorVisitor<Iter> {
SeqIteratorVisitor {
iter: iter,
@ -159,6 +190,7 @@ impl<
S: VisitorState<R>,
R
> Visitor<S, R> for SeqIteratorVisitor<Iter> {
#[inline]
fn visit(&mut self, state: &mut S) -> Option<R> {
let first = self.first;
self.first = false;
@ -169,6 +201,7 @@ impl<
}
}
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) {
self.iter.size_hint()
}
@ -181,6 +214,7 @@ impl<
R,
T: Serialize<S, R>
> Serialize<S, R> for Vec<T> {
#[inline]
fn serialize(&self, state: &mut S) -> R {
state.visit_seq(SeqIteratorVisitor::new(self.iter()))
}
@ -193,10 +227,8 @@ pub struct MapIteratorVisitor<Iter> {
first: bool,
}
impl<
K,
V,
Iter: Iterator<(K, V)>> MapIteratorVisitor<Iter> {
impl<K, V, Iter: Iterator<(K, V)>> MapIteratorVisitor<Iter> {
#[inline]
pub fn new(iter: Iter) -> MapIteratorVisitor<Iter> {
MapIteratorVisitor {
iter: iter,
@ -212,6 +244,7 @@ impl<
S: VisitorState<R>,
R
> Visitor<S, R> for MapIteratorVisitor<Iter> {
#[inline]
fn visit(&mut self, state: &mut S) -> Option<R> {
let first = self.first;
self.first = false;
@ -222,6 +255,7 @@ impl<
}
}
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) {
self.iter.size_hint()
}
@ -235,6 +269,7 @@ impl<
K: Serialize<S, R> + Ord,
V: Serialize<S, R>
> Serialize<S, R> for TreeMap<K, V> {
#[inline]
fn serialize(&self, state: &mut S) -> R {
state.visit_map(MapIteratorVisitor::new(self.iter()))
}
@ -247,6 +282,7 @@ impl<
T0: Serialize<S, R>,
T1: Serialize<S, R>
> Serialize<S, R> for (T0, T1) {
#[inline]
fn serialize(&self, state: &mut S) -> R {
state.visit_seq(Tuple2Serialize { value: self, state: 0 })
}
@ -264,6 +300,7 @@ impl<
T0: Serialize<S, R>,
T1: Serialize<S, R>
> Visitor<S, R> for Tuple2Serialize<'a, T0, T1> {
#[inline]
fn visit(&mut self, state: &mut S) -> Option<R> {
match self.state {
0 => {
@ -282,6 +319,7 @@ impl<
}
}
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) {
let size = 2 - self.state;
(size, Some(size))
@ -294,6 +332,7 @@ impl<
R,
T: Serialize<S, R>
> Serialize<S, R> for &'a T {
#[inline]
fn serialize(&self, state: &mut S) -> R {
(**self).serialize(state)
}
@ -302,7 +341,7 @@ impl<
///////////////////////////////////////////////////////////////////////////////
#[deriving(Show)]
pub enum Token {
pub enum Token<'a> {
Null,
Bool(bool),
Int(int),
@ -310,42 +349,43 @@ pub enum Token {
U64(u64),
F64(f64),
Char(char),
Str(&'static str),
Str(&'a str),
String(String),
SeqStart(uint),
MapStart(uint),
StructStart(&'static str, uint),
End,
}
pub trait TokenState<R>: VisitorState<R> {
fn serialize(&mut self, token: Token) -> R;
pub trait TokenState<'a, R>: VisitorState<R> {
fn serialize(&mut self, token: Token<'a>) -> R;
}
///////////////////////////////////////////////////////////////////////////////
pub struct GatherTokens {
tokens: Vec<Token>,
pub struct GatherTokens<'a> {
tokens: Vec<Token<'a>>,
}
impl GatherTokens {
pub fn new() -> GatherTokens {
impl<'a> GatherTokens<'a> {
pub fn new() -> GatherTokens<'a> {
GatherTokens {
tokens: Vec::new(),
}
}
pub fn unwrap(self) -> Vec<Token> {
pub fn unwrap(self) -> Vec<Token<'a>> {
self.tokens
}
}
impl TokenState<()> for GatherTokens {
fn serialize(&mut self, token: Token) -> () {
impl<'a> TokenState<'a, ()> for GatherTokens<'a> {
fn serialize(&mut self, token: Token<'a>) -> () {
self.tokens.push(token);
}
}
impl VisitorState<()> for GatherTokens {
impl<'a> VisitorState<()> for GatherTokens<'a> {
fn visit_null(&mut self) -> () {
self.serialize(Null)
}
@ -370,12 +410,12 @@ impl VisitorState<()> for GatherTokens {
self.serialize(Char(value))
}
fn visit_str(&mut self, value: &'static str) -> () {
self.serialize(Str(value))
fn visit_str(&mut self, value: &str) -> () {
self.serialize(String(value.to_string()))
}
fn visit_seq<
V: Visitor<GatherTokens, ()>
V: Visitor<GatherTokens<'a>, ()>
>(&mut self, mut visitor: V) -> () {
let (len, _) = visitor.size_hint();
self.tokens.push(SeqStart(len));
@ -389,13 +429,13 @@ impl VisitorState<()> for GatherTokens {
}
fn visit_seq_elt<
T: Serialize<GatherTokens, ()>
T: Serialize<GatherTokens<'a>, ()>
>(&mut self, _first: bool, value: T) -> () {
value.serialize(self)
}
fn visit_map<
V: Visitor<GatherTokens, ()>
V: Visitor<GatherTokens<'a>, ()>
>(&mut self, mut visitor: V) -> () {
let (len, _) = visitor.size_hint();
self.serialize(MapStart(len));
@ -409,7 +449,7 @@ impl VisitorState<()> for GatherTokens {
}
fn visit_named_map<
V: Visitor<GatherTokens, ()>
V: Visitor<GatherTokens<'a>, ()>
>(&mut self, name: &'static str, mut visitor: V) -> () {
let (len, _) = visitor.size_hint();
self.serialize(StructStart(name, len));
@ -423,8 +463,8 @@ impl VisitorState<()> for GatherTokens {
}
fn visit_map_elt<
K: Serialize<GatherTokens, ()>,
V: Serialize<GatherTokens, ()>
K: Serialize<GatherTokens<'a>, ()>,
V: Serialize<GatherTokens<'a>, ()>
>(&mut self, _first: bool, key: K, value: V) -> () {
key.serialize(self);
value.serialize(self)