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

rename de2.rs to de.rs

Browse Source
This commit is contained in:
Erick Tryzelaar 2014-10-06 21:55:33 -07:00
parent 150ec0d2d7
commit 2c50039c13
4 changed files with 341 additions and 435 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
serde2/src/bin.rs
View File

@ -4,8 +4,8 @@ use std::collections::HashMap;
use std::option;
use std::string;
use serde2::de2;
use serde2::de2::{Deserialize, Deserializer};
use serde2::de;
use serde2::de::{Deserialize, Deserializer};
#[deriving(Show)]
enum Token {
@ -61,7 +61,7 @@ impl<Iter: Iterator<Token>> MyDeserializer<Iter> {
impl<Iter: Iterator<Token>> Deserializer<Error> for MyDeserializer<Iter> {
fn visit<
R,
V: de2::Visitor<MyDeserializer<Iter>, R, Error>,
V: de::Visitor<MyDeserializer<Iter>, R, Error>,
>(&mut self, visitor: &mut V) -> Result<R, Error> {
match self.next() {
Some(Null) => {
@ -95,7 +95,7 @@ impl<Iter: Iterator<Token>> Deserializer<Error> for MyDeserializer<Iter> {
fn visit_option<
R,
V: de2::Visitor<MyDeserializer<Iter>, R, Error>,
V: de::Visitor<MyDeserializer<Iter>, R, Error>,
>(&mut self, visitor: &mut V) -> Result<R, Error> {
match self.peek() {
Some(&Null) => {
@ -133,7 +133,7 @@ struct MyOptionVisitor {
impl<
Iter: Iterator<Token>,
> de2::OptionVisitor<MyDeserializer<Iter>, Error> for MyOptionVisitor {
> de::OptionVisitor<MyDeserializer<Iter>, Error> for MyOptionVisitor {
fn visit<
T: Deserialize<MyDeserializer<Iter>, Error>,
>(&mut self, d: &mut MyDeserializer<Iter>) -> Result<option::Option<T>, Error> {
@ -153,7 +153,7 @@ struct MySeqVisitor {
impl<
Iter: Iterator<Token>,
> de2::SeqVisitor<MyDeserializer<Iter>, Error> for MySeqVisitor {
> de::SeqVisitor<MyDeserializer<Iter>, Error> for MySeqVisitor {
fn visit<
T: Deserialize<MyDeserializer<Iter>, Error>
>(&mut self, d: &mut MyDeserializer<Iter>) -> Result<option::Option<T>, Error> {
@ -192,7 +192,7 @@ struct MyMapVisitor {
impl<
Iter: Iterator<Token>,
> de2::MapVisitor<MyDeserializer<Iter>, Error> for MyMapVisitor {
> de::MapVisitor<MyDeserializer<Iter>, Error> for MyMapVisitor {
fn visit<
K: Deserialize<MyDeserializer<Iter>, Error>,
V: Deserialize<MyDeserializer<Iter>, Error>,
@ -233,7 +233,7 @@ impl<
mod json {
use std::collections::TreeMap;
use serde2::de2;
use serde2::de;
#[deriving(Show)]
pub enum Value {
@ -246,16 +246,16 @@ mod json {
}
impl<
D: de2::Deserializer<E>,
D: de::Deserializer<E>,
E,
> de2::Deserialize<D, E> for Value {
> de::Deserialize<D, E> for Value {
fn deserialize(d: &mut D) -> Result<Value, E> {
struct Visitor;
impl<
D: de2::Deserializer<E>,
D: de::Deserializer<E>,
E,
> de2::Visitor<D, Value, E> for Visitor {
> de::Visitor<D, Value, E> for Visitor {
fn visit_null(&mut self, _d: &mut D) -> Result<Value, E> {
Ok(Null)
}
@ -271,7 +271,7 @@ mod json {
*/
fn visit_option<
Visitor: de2::OptionVisitor<D, E>,
Visitor: de::OptionVisitor<D, E>,
>(&mut self, d: &mut D, mut visitor: Visitor) -> Result<Value, E> {
match try!(visitor.visit(d)) {
Some(value) => Ok(value),
@ -280,7 +280,7 @@ mod json {
}
fn visit_seq<
Visitor: de2::SeqVisitor<D, E>,
Visitor: de::SeqVisitor<D, E>,
>(&mut self, d: &mut D, mut visitor: Visitor) -> Result<Value, E> {
let (len, _) = visitor.size_hint(d);
let mut values = Vec::with_capacity(len);
@ -300,7 +300,7 @@ mod json {
}
fn visit_map<
Visitor: de2::MapVisitor<D, E>,
Visitor: de::MapVisitor<D, E>,
>(&mut self, d: &mut D, mut visitor: Visitor) -> Result<Value, E> {
let mut values = TreeMap::new();
@ -480,8 +480,8 @@ fn main() {
/*
use std::collections::TreeMap;
use serde2::{Serialize, GatherTokens};
use serde2::json;
use serde::{Serialize, GatherTokens};
use serde::json;
///////////////////////////////////////////////////////////////////////////////
@ -491,7 +491,7 @@ struct Foo {
z: &'static str,
}
impl<S: serde2::VisitorState<R>, R> serde2::Serialize<S, R> for Foo {
impl<S: serde::VisitorState<R>, R> serde::Serialize<S, R> for Foo {
fn serialize(&self, state: &mut S) -> R {
state.visit_named_map("Foo", FooSerialize {
value: self,
@ -505,7 +505,7 @@ struct FooSerialize<'a> {
state: uint,
}
impl<'a, S: serde2::VisitorState<R>, R> serde2::Visitor<S, R> for FooSerialize<'a> {
impl<'a, S: serde::VisitorState<R>, R> serde::Visitor<S, R> for FooSerialize<'a> {
fn visit(&mut self, state: &mut S) -> Option<R> {
match self.state {
0 => {

376
serde2/src/de.rs
View File

@ -1,93 +1,359 @@
pub trait Deserialize<S, E> {
fn deserialize(state: &mut S) -> Result<Self, E>;
}
use std::collections::{HashMap, TreeMap};
use std::hash::Hash;
///////////////////////////////////////////////////////////////////////////////
pub trait Deserializer<D, R> {
fn deserialize<T: Deserialize<D, R>>(&mut self) -> R;
pub trait Deserialize<D, E> {
fn deserialize(d: &mut D) -> Result<Self, E>;
}
///////////////////////////////////////////////////////////////////////////////
pub trait Deserializer<E> {
fn visit<
R,
V: Visitor<Self, R, E>,
>(&mut self, visitor: &mut V) -> Result<R, E>;
pub trait Visitor<D, R> {
fn visit(&mut self, state: &mut S) -> Option<R>;
fn visit_option<
R,
V: Visitor<Self, R, E>,
>(&mut self, visitor: &mut V) -> Result<R, E> {
self.visit(visitor)
}
fn syntax_error(&mut self) -> E;
fn end_of_stream_error(&mut self) -> E;
}
pub trait Visitor<D: Deserializer<E>, R, E> {
fn visit_null(&mut self, d: &mut D) -> Result<R, E> {
Err(d.syntax_error())
}
fn visit_int(&mut self, d: &mut D, _v: int) -> Result<R, E> {
Err(d.syntax_error())
}
fn visit_str(&mut self, d: &mut D, v: &str) -> Result<R, E> {
self.visit_string(d, v.to_string())
}
fn visit_string(&mut self, d: &mut D, _v: String) -> Result<R, E> {
Err(d.syntax_error())
}
fn visit_option<
V: OptionVisitor<D, E>,
>(&mut self, d: &mut D, _visitor: V) -> Result<R, E> {
Err(d.syntax_error())
}
fn visit_seq<
V: SeqVisitor<D, E>,
>(&mut self, d: &mut D, _visitor: V) -> Result<R, E> {
Err(d.syntax_error())
}
fn visit_map<
V: MapVisitor<D, E>,
>(&mut self, d: &mut D, _visitor: V) -> Result<R, E> {
Err(d.syntax_error())
}
}
pub trait OptionVisitor<D, E> {
fn visit<
T: Deserialize<D, E>,
>(&mut self, d: &mut D) -> Result<Option<T>, E>;
}
pub trait SeqVisitor<D, E> {
fn visit<
T: Deserialize<D, E>,
>(&mut self, d: &mut D) -> Result<Option<T>, E>;
fn end(&mut self, d: &mut D) -> Result<(), E>;
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) {
fn size_hint(&self, _d: &mut D) -> (uint, Option<uint>) {
(0, None)
}
}
pub trait SeqVisitor {
pub trait MapVisitor<D, E> {
fn visit<
K: Deserialize<D, E>,
V: Deserialize<D, E>,
>(&mut self, d: &mut D) -> Result<Option<(K, V)>, E>;
}
fn end(&mut self, d: &mut D) -> Result<(), E>;
pub trait VisitorState<E> {
fn syntax_error(&mut self) -> E;
fn visit_int(&mut self) -> Result<int, E> {
#[inline]
fn size_hint(&self, _d: &mut D) -> (uint, Option<uint>) {
(0, None)
}
fn visit_seq<Iter: FromIterator>(&mut self, ) -> Iter
}
///////////////////////////////////////////////////////////////////////////////
impl<D: VisitorState<E>, E> Deserialize<D, E> for int {
#[inline]
fn deserialize(state: &mut D) -> Result<int, E> {
state.visit_int()
impl<
D: Deserializer<E>,
E,
> Deserialize<D, E> for () {
fn deserialize(d: &mut D) -> Result<(), E> {
struct Visitor;
impl<D: Deserializer<E>, E> self::Visitor<D, (), E> for Visitor {
fn visit_null(&mut self, _d: &mut D) -> Result<(), E> {
Ok(())
}
}
d.visit(&mut Visitor)
}
}
///////////////////////////////////////////////////////////////////////////////
impl<
D: Deserializer<E>,
E,
> Deserialize<D, E> for int {
fn deserialize(d: &mut D) -> Result<int, E> {
struct Visitor;
impl<D: Deserializer<E>, E> self::Visitor<D, int, E> for Visitor {
fn visit_int(&mut self, _d: &mut D, v: int) -> Result<int, E> {
Ok(v)
}
}
d.visit(&mut Visitor)
}
}
///////////////////////////////////////////////////////////////////////////////
impl<
D: Deserializer<E>,
E,
> Deserialize<D, E> for String {
fn deserialize(d: &mut D) -> Result<String, E> {
struct Visitor;
impl<D: Deserializer<E>, E> self::Visitor<D, String, E> for Visitor {
fn visit_string(&mut self, _d: &mut D, v: String) -> Result<String, E> {
Ok(v)
}
}
d.visit(&mut Visitor)
}
}
///////////////////////////////////////////////////////////////////////////////
impl<
T: Deserialize<D, E>,
D: VisitorState<E>,
E
> Deserialize<D, E> for Vec<T> {
#[inline]
fn deserialize(state: &mut D) -> Result<int, E> {
struct SeqVisitor {
D: Deserializer<E>,
E,
> Deserialize<D, E> for Option<T> {
fn deserialize(d: &mut D) -> Result<Option<T>, E> {
struct Visitor;
impl<
T: Deserialize<D, E>,
D: Deserializer<E>,
E,
> self::Visitor<D, Option<T>, E> for Visitor {
fn visit_option<
V: OptionVisitor<D, E>,
>(&mut self, d: &mut D, mut visitor: V) -> Result<Option<T>, E> {
visitor.visit(d)
}
}
impl SeqVisitor {
fn visit_seq<V: Visitor<Self>>(len: uint, visitor: V) {
let mut value = Vec::with_capacity(len);
d.visit_option(&mut Visitor)
}
}
///////////////////////////////////////////////////////////////////////////////
impl<
T: Deserialize<D, E>,
D: Deserializer<E>,
E,
> Deserialize<D, E> for Vec<T> {
fn deserialize(d: &mut D) -> Result<Vec<T>, E> {
struct Visitor;
impl<
T: Deserialize<D, E>,
D: Deserializer<E>,
E,
> self::Visitor<D, Vec<T>, E> for Visitor {
fn visit_seq<
V: SeqVisitor<D, E>,
>(&mut self, d: &mut D, mut visitor: V) -> Result<Vec<T>, E> {
let (len, _) = visitor.size_hint(d);
let mut values = Vec::with_capacity(len);
loop {
match visitor.visit(self, &mut value) {
Some(()) => { }
None => { break; }
match try!(visitor.visit(d)) {
Some(value) => {
values.push(value);
}
None => {
break;
}
}
}
value
}
fn visit_seq_elt<
T: S
>(&mut self, value: &mut Vec<T>) {
let v = Deserialize
value.push(
Ok(values)
}
}
let v = Vec::new();
state.visit_seq()
d.visit(&mut Visitor)
}
}
impl<
T0: Deserialize<D, E>,
T1: Deserialize<D, E>,
D: Deserializer<E>,
E,
> Deserialize<D, E> for (T0, T1) {
fn deserialize(d: &mut D) -> Result<(T0, T1), E> {
struct Visitor;
impl<
T0: Deserialize<D, E>,
T1: Deserialize<D, E>,
D: Deserializer<E>,
E,
> self::Visitor<D, (T0, T1), E> for Visitor {
fn visit_seq<
V: SeqVisitor<D, E>,
>(&mut self, d: &mut D, mut visitor: V) -> Result<(T0, T1), E> {
let mut state = 0u;
let mut t0 = None;
let mut t1 = None;
loop {
match state {
0 => {
state += 1;
match try!(visitor.visit(d)) {
Some(value) => {
t0 = Some(value);
}
None => {
return Err(d.end_of_stream_error());
}
}
}
1 => {
state += 1;
match try!(visitor.visit(d)) {
Some(value) => {
t1 = Some(value);
}
None => {
return Err(d.end_of_stream_error());
}
}
}
_ => {
try!(visitor.end(d));
return Ok((t0.unwrap(), t1.unwrap()));
}
}
}
}
}
d.visit(&mut Visitor)
}
}
///////////////////////////////////////////////////////////////////////////////
impl<
K: Deserialize<D, E> + Eq + Hash,
V: Deserialize<D, E>,
D: Deserializer<E>,
E,
> Deserialize<D, E> for HashMap<K, V> {
fn deserialize(d: &mut D) -> Result<HashMap<K, V>, E> {
struct Visitor;
impl<
K: Deserialize<D, E> + Eq + Hash,
V: Deserialize<D, E>,
D: Deserializer<E>,
E,
> self::Visitor<D, HashMap<K, V>, E> for Visitor {
fn visit_map<
Visitor: MapVisitor<D, E>,
>(&mut self, d: &mut D, mut visitor: Visitor) -> Result<HashMap<K, V>, E> {
let (len, _) = visitor.size_hint(d);
let mut values = HashMap::with_capacity(len);
loop {
match try!(visitor.visit(d)) {
Some((key, value)) => {
values.insert(key, value);
}
None => {
break;
}
}
}
Ok(values)
}
}
d.visit(&mut Visitor)
}
}
impl<
K: Deserialize<D, E> + Eq + Ord,
V: Deserialize<D, E>,
D: Deserializer<E>,
E,
> Deserialize<D, E> for TreeMap<K, V> {
fn deserialize(d: &mut D) -> Result<TreeMap<K, V>, E> {
struct Visitor;
impl<
K: Deserialize<D, E> + Eq + Ord,
V: Deserialize<D, E>,
D: Deserializer<E>,
E,
> self::Visitor<D, TreeMap<K, V>, E> for Visitor {
fn visit_map<
Visitor: MapVisitor<D, E>,
>(&mut self, d: &mut D, mut visitor: Visitor) -> Result<TreeMap<K, V>, E> {
let mut values = TreeMap::new();
loop {
match try!(visitor.visit(d)) {
Some((key, value)) => {
values.insert(key, value);
}
None => {
break;
}
}
}
Ok(values)
}
}
d.visit(&mut Visitor)
}
}

359
serde2/src/de2.rs
View File

@ -1,359 +0,0 @@
use std::collections::{HashMap, TreeMap};
use std::hash::Hash;
///////////////////////////////////////////////////////////////////////////////
pub trait Deserialize<D, E> {
fn deserialize(d: &mut D) -> Result<Self, E>;
}
pub trait Deserializer<E> {
fn visit<
R,
V: Visitor<Self, R, E>,
>(&mut self, visitor: &mut V) -> Result<R, E>;
fn visit_option<
R,
V: Visitor<Self, R, E>,
>(&mut self, visitor: &mut V) -> Result<R, E> {
self.visit(visitor)
}
fn syntax_error(&mut self) -> E;
fn end_of_stream_error(&mut self) -> E;
}
pub trait Visitor<D: Deserializer<E>, R, E> {
fn visit_null(&mut self, d: &mut D) -> Result<R, E> {
Err(d.syntax_error())
}
fn visit_int(&mut self, d: &mut D, _v: int) -> Result<R, E> {
Err(d.syntax_error())
}
fn visit_str(&mut self, d: &mut D, v: &str) -> Result<R, E> {
self.visit_string(d, v.to_string())
}
fn visit_string(&mut self, d: &mut D, _v: String) -> Result<R, E> {
Err(d.syntax_error())
}
fn visit_option<
V: OptionVisitor<D, E>,
>(&mut self, d: &mut D, _visitor: V) -> Result<R, E> {
Err(d.syntax_error())
}
fn visit_seq<
V: SeqVisitor<D, E>,
>(&mut self, d: &mut D, _visitor: V) -> Result<R, E> {
Err(d.syntax_error())
}
fn visit_map<
V: MapVisitor<D, E>,
>(&mut self, d: &mut D, _visitor: V) -> Result<R, E> {
Err(d.syntax_error())
}
}
pub trait OptionVisitor<D, E> {
fn visit<
T: Deserialize<D, E>,
>(&mut self, d: &mut D) -> Result<Option<T>, E>;
}
pub trait SeqVisitor<D, E> {
fn visit<
T: Deserialize<D, E>,
>(&mut self, d: &mut D) -> Result<Option<T>, E>;
fn end(&mut self, d: &mut D) -> Result<(), E>;
#[inline]
fn size_hint(&self, _d: &mut D) -> (uint, Option<uint>) {
(0, None)
}
}
pub trait MapVisitor<D, E> {
fn visit<
K: Deserialize<D, E>,
V: Deserialize<D, E>,
>(&mut self, d: &mut D) -> Result<Option<(K, V)>, E>;
fn end(&mut self, d: &mut D) -> Result<(), E>;
#[inline]
fn size_hint(&self, _d: &mut D) -> (uint, Option<uint>) {
(0, None)
}
}
///////////////////////////////////////////////////////////////////////////////
impl<
D: Deserializer<E>,
E,
> Deserialize<D, E> for () {
fn deserialize(d: &mut D) -> Result<(), E> {
struct Visitor;
impl<D: Deserializer<E>, E> self::Visitor<D, (), E> for Visitor {
fn visit_null(&mut self, _d: &mut D) -> Result<(), E> {
Ok(())
}
}
d.visit(&mut Visitor)
}
}
///////////////////////////////////////////////////////////////////////////////
impl<
D: Deserializer<E>,
E,
> Deserialize<D, E> for int {
fn deserialize(d: &mut D) -> Result<int, E> {
struct Visitor;
impl<D: Deserializer<E>, E> self::Visitor<D, int, E> for Visitor {
fn visit_int(&mut self, _d: &mut D, v: int) -> Result<int, E> {
Ok(v)
}
}
d.visit(&mut Visitor)
}
}
///////////////////////////////////////////////////////////////////////////////
impl<
D: Deserializer<E>,
E,
> Deserialize<D, E> for String {
fn deserialize(d: &mut D) -> Result<String, E> {
struct Visitor;
impl<D: Deserializer<E>, E> self::Visitor<D, String, E> for Visitor {
fn visit_string(&mut self, _d: &mut D, v: String) -> Result<String, E> {
Ok(v)
}
}
d.visit(&mut Visitor)
}
}
///////////////////////////////////////////////////////////////////////////////
impl<
T: Deserialize<D, E>,
D: Deserializer<E>,
E,
> Deserialize<D, E> for Option<T> {
fn deserialize(d: &mut D) -> Result<Option<T>, E> {
struct Visitor;
impl<
T: Deserialize<D, E>,
D: Deserializer<E>,
E,
> self::Visitor<D, Option<T>, E> for Visitor {
fn visit_option<
V: OptionVisitor<D, E>,
>(&mut self, d: &mut D, mut visitor: V) -> Result<Option<T>, E> {
visitor.visit(d)
}
}
d.visit_option(&mut Visitor)
}
}
///////////////////////////////////////////////////////////////////////////////
impl<
T: Deserialize<D, E>,
D: Deserializer<E>,
E,
> Deserialize<D, E> for Vec<T> {
fn deserialize(d: &mut D) -> Result<Vec<T>, E> {
struct Visitor;
impl<
T: Deserialize<D, E>,
D: Deserializer<E>,
E,
> self::Visitor<D, Vec<T>, E> for Visitor {
fn visit_seq<
V: SeqVisitor<D, E>,
>(&mut self, d: &mut D, mut visitor: V) -> Result<Vec<T>, E> {
let (len, _) = visitor.size_hint(d);
let mut values = Vec::with_capacity(len);
loop {
match try!(visitor.visit(d)) {
Some(value) => {
values.push(value);
}
None => {
break;
}
}
}
Ok(values)
}
}
d.visit(&mut Visitor)
}
}
impl<
T0: Deserialize<D, E>,
T1: Deserialize<D, E>,
D: Deserializer<E>,
E,
> Deserialize<D, E> for (T0, T1) {
fn deserialize(d: &mut D) -> Result<(T0, T1), E> {
struct Visitor;
impl<
T0: Deserialize<D, E>,
T1: Deserialize<D, E>,
D: Deserializer<E>,
E,
> self::Visitor<D, (T0, T1), E> for Visitor {
fn visit_seq<
V: SeqVisitor<D, E>,
>(&mut self, d: &mut D, mut visitor: V) -> Result<(T0, T1), E> {
let mut state = 0u;
let mut t0 = None;
let mut t1 = None;
loop {
match state {
0 => {
state += 1;
match try!(visitor.visit(d)) {
Some(value) => {
t0 = Some(value);
}
None => {
return Err(d.end_of_stream_error());
}
}
}
1 => {
state += 1;
match try!(visitor.visit(d)) {
Some(value) => {
t1 = Some(value);
}
None => {
return Err(d.end_of_stream_error());
}
}
}
_ => {
try!(visitor.end(d));
return Ok((t0.unwrap(), t1.unwrap()));
}
}
}
}
}
d.visit(&mut Visitor)
}
}
///////////////////////////////////////////////////////////////////////////////
impl<
K: Deserialize<D, E> + Eq + Hash,
V: Deserialize<D, E>,
D: Deserializer<E>,
E,
> Deserialize<D, E> for HashMap<K, V> {
fn deserialize(d: &mut D) -> Result<HashMap<K, V>, E> {
struct Visitor;
impl<
K: Deserialize<D, E> + Eq + Hash,
V: Deserialize<D, E>,
D: Deserializer<E>,
E,
> self::Visitor<D, HashMap<K, V>, E> for Visitor {
fn visit_map<
Visitor: MapVisitor<D, E>,
>(&mut self, d: &mut D, mut visitor: Visitor) -> Result<HashMap<K, V>, E> {
let (len, _) = visitor.size_hint(d);
let mut values = HashMap::with_capacity(len);
loop {
match try!(visitor.visit(d)) {
Some((key, value)) => {
values.insert(key, value);
}
None => {
break;
}
}
}
Ok(values)
}
}
d.visit(&mut Visitor)
}
}
impl<
K: Deserialize<D, E> + Eq + Ord,
V: Deserialize<D, E>,
D: Deserializer<E>,
E,
> Deserialize<D, E> for TreeMap<K, V> {
fn deserialize(d: &mut D) -> Result<TreeMap<K, V>, E> {
struct Visitor;
impl<
K: Deserialize<D, E> + Eq + Ord,
V: Deserialize<D, E>,
D: Deserializer<E>,
E,
> self::Visitor<D, TreeMap<K, V>, E> for Visitor {
fn visit_map<
Visitor: MapVisitor<D, E>,
>(&mut self, d: &mut D, mut visitor: Visitor) -> Result<TreeMap<K, V>, E> {
let mut values = TreeMap::new();
loop {
match try!(visitor.visit(d)) {
Some((key, value)) => {
values.insert(key, value);
}
None => {
break;
}
}
}
Ok(values)
}
}
d.visit(&mut Visitor)
}
}

3
serde2/src/lib.rs
View File

@ -5,6 +5,5 @@
//pub use ser::GatherTokens;
pub mod ser;
//pub mod de;
pub mod de2;
pub mod de;
//pub mod json;