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

Minor renaming

Browse Source
This commit is contained in:
Erick Tryzelaar
2014-09-14 19:10:07 -04:00
parent 755cfb339d
commit b334136f6e
1 changed files with 150 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde2/src/de2.rs
+150 -150
View File
@@ -3,13 +3,19 @@ use std::hash::Hash;
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
trait Deserialize<S, E> { trait Deserialize<D, E> {
fn deserialize(state: &mut S) -> Result<Self, E>; fn deserialize(d: &mut D) -> Result<Self, E>;
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
trait VisitorState<E> { trait Deserializer<D, E> {
fn deserialize<T: Deserialize<D, E>>(&mut self) -> Result<T, E>;
}
///////////////////////////////////////////////////////////////////////////////
trait DeserializerState<E> {
fn syntax_error(&mut self) -> E; fn syntax_error(&mut self) -> E;
fn visit< fn visit<
@@ -20,38 +26,38 @@ trait VisitorState<E> {
trait Visitor< trait Visitor<
T, T,
S: VisitorState<E>, D: DeserializerState<E>,
E, E,
> { > {
fn visit_null(&mut self, state: &mut S) -> Result<T, E> { fn visit_null(&mut self, d: &mut D) -> Result<T, E> {
Err(state.syntax_error()) Err(d.syntax_error())
} }
fn visit_int(&mut self, state: &mut S, _v: int) -> Result<T, E> { fn visit_int(&mut self, d: &mut D, _v: int) -> Result<T, E> {
Err(state.syntax_error()) Err(d.syntax_error())
} }
fn visit_string(&mut self, state: &mut S, _v: String) -> Result<T, E> { fn visit_string(&mut self, d: &mut D, _v: String) -> Result<T, E> {
Err(state.syntax_error()) Err(d.syntax_error())
} }
fn visit_seq< fn visit_seq<
V: SeqVisitor<S, E>, V: SeqVisitor<D, E>,
>(&mut self, state: &mut S, _visitor: V) -> Result<T, E> { >(&mut self, d: &mut D, _visitor: V) -> Result<T, E> {
Err(state.syntax_error()) Err(d.syntax_error())
} }
fn visit_map< fn visit_map<
V: MapVisitor<S, E>, V: MapVisitor<D, E>,
>(&mut self, state: &mut S, _visitor: V) -> Result<T, E> { >(&mut self, d: &mut D, _visitor: V) -> Result<T, E> {
Err(state.syntax_error()) Err(d.syntax_error())
} }
} }
trait SeqVisitor<S, E> { trait SeqVisitor<D, E> {
fn next< fn next<
T: Deserialize<S, E>, T: Deserialize<D, E>,
>(&mut self, state: &mut S) -> Option<Result<T, E>>; >(&mut self, d: &mut D) -> Option<Result<T, E>>;
#[inline] #[inline]
fn size_hint(&self) -> (uint, Option<uint>) { fn size_hint(&self) -> (uint, Option<uint>) {
@@ -59,11 +65,11 @@ trait SeqVisitor<S, E> {
} }
} }
trait MapVisitor<S, E> { trait MapVisitor<D, E> {
fn next< fn next<
K: Deserialize<S, E>, K: Deserialize<D, E>,
V: Deserialize<S, E>, V: Deserialize<D, E>,
>(&mut self, state: &mut S) -> Option<Result<(K, V), E>>; >(&mut self, d: &mut D) -> Option<Result<(K, V), E>>;
#[inline] #[inline]
fn size_hint(&self) -> (uint, Option<uint>) { fn size_hint(&self) -> (uint, Option<uint>) {
@@ -75,68 +81,68 @@ trait MapVisitor<S, E> {
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
impl< impl<
S: VisitorState<E>, D: DeserializerState<E>,
E, E,
> Deserialize<S, E> for int { > Deserialize<D, E> for int {
fn deserialize(state: &mut S) -> Result<int, E> { fn deserialize(d: &mut D) -> Result<int, E> {
struct Visitor; struct Visitor;
impl< impl<
S: VisitorState<E>, D: DeserializerState<E>,
E, E,
> ::Visitor<int, S, E> for Visitor { > ::Visitor<int, D, E> for Visitor {
fn visit_int(&mut self, _state: &mut S, v: int) -> Result<int, E> { fn visit_int(&mut self, _d: &mut D, v: int) -> Result<int, E> {
Ok(v) Ok(v)
} }
} }
state.visit(&mut Visitor) d.visit(&mut Visitor)
} }
} }
impl< impl<
S: VisitorState<E>, D: DeserializerState<E>,
E, E,
> Deserialize<S, E> for String { > Deserialize<D, E> for String {
fn deserialize(state: &mut S) -> Result<String, E> { fn deserialize(d: &mut D) -> Result<String, E> {
struct Visitor; struct Visitor;
impl< impl<
S: VisitorState<E>, D: DeserializerState<E>,
E, E,
> ::Visitor<String, S, E> for Visitor { > ::Visitor<String, D, E> for Visitor {
fn visit_string(&mut self, _state: &mut S, v: String) -> Result<String, E> { fn visit_string(&mut self, _d: &mut D, v: String) -> Result<String, E> {
Ok(v) Ok(v)
} }
} }
state.visit(&mut Visitor) d.visit(&mut Visitor)
} }
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
impl< impl<
T: Deserialize<S, E>, T: Deserialize<D, E>,
S: VisitorState<E>, D: DeserializerState<E>,
E, E,
> Deserialize<S, E> for Vec<T> { > Deserialize<D, E> for Vec<T> {
fn deserialize(state: &mut S) -> Result<Vec<T>, E> { fn deserialize(d: &mut D) -> Result<Vec<T>, E> {
struct Visitor; struct Visitor;
impl< impl<
T: Deserialize<S, E>, T: Deserialize<D, E>,
S: VisitorState<E>, D: DeserializerState<E>,
E, E,
> ::Visitor<Vec<T>, S, E> for Visitor { > ::Visitor<Vec<T>, D, E> for Visitor {
fn visit_seq< fn visit_seq<
Visitor: SeqVisitor<S, E>, Visitor: SeqVisitor<D, E>,
>(&mut self, state: &mut S, mut visitor: Visitor) -> Result<Vec<T>, E> { >(&mut self, d: &mut D, mut visitor: Visitor) -> Result<Vec<T>, E> {
let (len, _) = visitor.size_hint(); let (len, _) = visitor.size_hint();
let mut values = Vec::with_capacity(len); let mut values = Vec::with_capacity(len);
loop { loop {
match visitor.next(state) { match visitor.next(d) {
Some(Ok(value)) => { Some(Ok(value)) => {
values.push(value); values.push(value);
} }
@@ -153,52 +159,52 @@ impl<
} }
} }
state.visit(&mut Visitor) d.visit(&mut Visitor)
} }
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
impl< impl<
S: VisitorState<E>, D: DeserializerState<E>,
E E
> Deserialize<S, E> for () { > Deserialize<D, E> for () {
fn deserialize(state: &mut S) -> Result<(), E> { fn deserialize(d: &mut D) -> Result<(), E> {
struct Visitor; struct Visitor;
impl< impl<
S: VisitorState<E>, D: DeserializerState<E>,
E, E,
> ::Visitor<(), S, E> for Visitor { > ::Visitor<(), D, E> for Visitor {
fn visit_null(&mut self, _state: &mut S) -> Result<(), E> { fn visit_null(&mut self, _d: &mut D) -> Result<(), E> {
Ok(()) Ok(())
} }
} }
state.visit(&mut Visitor) d.visit(&mut Visitor)
} }
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
impl< impl<
T0: Deserialize<S, E>, T0: Deserialize<D, E>,
T1: Deserialize<S, E>, T1: Deserialize<D, E>,
S: VisitorState<E>, D: DeserializerState<E>,
E E
> Deserialize<S, E> for (T0, T1) { > Deserialize<D, E> for (T0, T1) {
fn deserialize(state: &mut S) -> Result<(T0, T1), E> { fn deserialize(d: &mut D) -> Result<(T0, T1), E> {
struct Visitor; struct Visitor;
impl< impl<
T0: Deserialize<S, E>, T0: Deserialize<D, E>,
T1: Deserialize<S, E>, T1: Deserialize<D, E>,
S: VisitorState<E>, D: DeserializerState<E>,
E E
> ::Visitor<(T0, T1), S, E> for Visitor { > ::Visitor<(T0, T1), D, E> for Visitor {
fn visit_seq< fn visit_seq<
Visitor: SeqVisitor<S, E>, Visitor: SeqVisitor<D, E>,
>(&mut self, visitor_state: &mut S, mut visitor: Visitor) -> Result<(T0, T1), E> { >(&mut self, d: &mut D, mut visitor: Visitor) -> Result<(T0, T1), E> {
let mut state = 0u; let mut state = 0u;
let mut t0 = None; let mut t0 = None;
let mut t1 = None; let mut t1 = None;
@@ -206,24 +212,24 @@ impl<
loop { loop {
match state { match state {
0 => { 0 => {
t0 = match visitor.next(visitor_state) { t0 = match visitor.next(d) {
Some(Ok(v)) => Some(v), Some(Ok(v)) => Some(v),
Some(Err(err)) => { return Err(err); } Some(Err(err)) => { return Err(err); }
None => { return Err(visitor_state.syntax_error()); } None => { return Err(d.syntax_error()); }
}; };
state += 1; state += 1;
} }
1 => { 1 => {
t1 = match visitor.next(visitor_state) { t1 = match visitor.next(d) {
Some(Ok(v)) => Some(v), Some(Ok(v)) => Some(v),
Some(Err(err)) => { return Err(err); } Some(Err(err)) => { return Err(err); }
None => { return Err(visitor_state.syntax_error()); } None => { return Err(d.syntax_error()); }
}; };
state += 1; state += 1;
} }
_ => { _ => {
match visitor.next(visitor_state) { match visitor.next(d) {
Some(Ok(())) => { return Err(visitor_state.syntax_error()); } Some(Ok(())) => { return Err(d.syntax_error()); }
Some(Err(err)) => { return Err(err); } Some(Err(err)) => { return Err(err); }
None => { break; } None => { break; }
} }
@@ -233,40 +239,40 @@ impl<
match (t0, t1) { match (t0, t1) {
(Some(t0), Some(t1)) => Ok((t0, t1)), (Some(t0), Some(t1)) => Ok((t0, t1)),
_ => Err(visitor_state.syntax_error()), _ => Err(d.syntax_error()),
} }
} }
} }
state.visit(&mut Visitor) d.visit(&mut Visitor)
} }
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
impl< impl<
K: Deserialize<S, E> + Eq + Hash, K: Deserialize<D, E> + Eq + Hash,
V: Deserialize<S, E>, V: Deserialize<D, E>,
S: VisitorState<E>, D: DeserializerState<E>,
E E
> Deserialize<S, E> for HashMap<K, V> { > Deserialize<D, E> for HashMap<K, V> {
fn deserialize(state: &mut S) -> Result<HashMap<K, V>, E> { fn deserialize(d: &mut D) -> Result<HashMap<K, V>, E> {
struct Visitor; struct Visitor;
impl< impl<
K: Deserialize<S, E> + Eq + Hash, K: Deserialize<D, E> + Eq + Hash,
V: Deserialize<S, E>, V: Deserialize<D, E>,
S: VisitorState<E>, D: DeserializerState<E>,
E, E,
> ::Visitor<HashMap<K, V>, S, E> for Visitor { > ::Visitor<HashMap<K, V>, D, E> for Visitor {
fn visit_map< fn visit_map<
Visitor: MapVisitor<S, E>, Visitor: MapVisitor<D, E>,
>(&mut self, state: &mut S, mut visitor: Visitor) -> Result<HashMap<K, V>, E> { >(&mut self, d: &mut D, mut visitor: Visitor) -> Result<HashMap<K, V>, E> {
let (len, _) = visitor.size_hint(); let (len, _) = visitor.size_hint();
let mut values = HashMap::with_capacity(len); let mut values = HashMap::with_capacity(len);
loop { loop {
match visitor.next(state) { match visitor.next(d) {
Some(Ok((key, value))) => { Some(Ok((key, value))) => {
values.insert(key, value); values.insert(key, value);
} }
@@ -283,32 +289,32 @@ impl<
} }
} }
state.visit(&mut Visitor) d.visit(&mut Visitor)
} }
} }
impl< impl<
K: Deserialize<S, E> + Eq + Ord, K: Deserialize<D, E> + Eq + Ord,
V: Deserialize<S, E>, V: Deserialize<D, E>,
S: VisitorState<E>, D: DeserializerState<E>,
E E
> Deserialize<S, E> for TreeMap<K, V> { > Deserialize<D, E> for TreeMap<K, V> {
fn deserialize(state: &mut S) -> Result<TreeMap<K, V>, E> { fn deserialize(d: &mut D) -> Result<TreeMap<K, V>, E> {
struct Visitor; struct Visitor;
impl< impl<
K: Deserialize<S, E> + Eq + Ord, K: Deserialize<D, E> + Eq + Ord,
V: Deserialize<S, E>, V: Deserialize<D, E>,
S: VisitorState<E>, D: DeserializerState<E>,
E, E,
> ::Visitor<TreeMap<K, V>, S, E> for Visitor { > ::Visitor<TreeMap<K, V>, D, E> for Visitor {
fn visit_map< fn visit_map<
Visitor: MapVisitor<S, E>, Visitor: MapVisitor<D, E>,
>(&mut self, state: &mut S, mut visitor: Visitor) -> Result<TreeMap<K, V>, E> { >(&mut self, d: &mut D, mut visitor: Visitor) -> Result<TreeMap<K, V>, E> {
let mut values = TreeMap::new(); let mut values = TreeMap::new();
loop { loop {
match visitor.next(state) { match visitor.next(d) {
Some(Ok((key, value))) => { Some(Ok((key, value))) => {
values.insert(key, value); values.insert(key, value);
} }
@@ -325,7 +331,7 @@ impl<
} }
} }
state.visit(&mut Visitor) d.visit(&mut Visitor)
} }
} }
@@ -345,36 +351,36 @@ mod json {
} }
impl< impl<
S: super::VisitorState<E>, D: super::DeserializerState<E>,
E, E,
> super::Deserialize<S, E> for Value { > super::Deserialize<D, E> for Value {
fn deserialize(state: &mut S) -> Result<Value, E> { fn deserialize(d: &mut D) -> Result<Value, E> {
struct Visitor; struct Visitor;
impl< impl<
S: super::VisitorState<E>, D: super::DeserializerState<E>,
E, E,
> super::Visitor<Value, S, E> for Visitor { > super::Visitor<Value, D, E> for Visitor {
fn visit_null(&mut self, _state: &mut S) -> Result<Value, E> { fn visit_null(&mut self, _d: &mut D) -> Result<Value, E> {
Ok(Null) Ok(Null)
} }
fn visit_int(&mut self, _state: &mut S, v: int) -> Result<Value, E> { fn visit_int(&mut self, _d: &mut D, v: int) -> Result<Value, E> {
Ok(Int(v)) Ok(Int(v))
} }
fn visit_string(&mut self, _state: &mut S, v: String) -> Result<Value, E> { fn visit_string(&mut self, _d: &mut D, v: String) -> Result<Value, E> {
Ok(String(v)) Ok(String(v))
} }
fn visit_seq< fn visit_seq<
Visitor: ::SeqVisitor<S, E>, Visitor: ::SeqVisitor<D, E>,
>(&mut self, state: &mut S, mut visitor: Visitor) -> Result<Value, E> { >(&mut self, d: &mut D, mut visitor: Visitor) -> Result<Value, E> {
let (len, _) = visitor.size_hint(); let (len, _) = visitor.size_hint();
let mut values = Vec::with_capacity(len); let mut values = Vec::with_capacity(len);
loop { loop {
match visitor.next(state) { match visitor.next(d) {
Some(Ok(value)) => { Some(Ok(value)) => {
values.push(value); values.push(value);
} }
@@ -391,12 +397,12 @@ mod json {
} }
fn visit_map< fn visit_map<
Visitor: ::MapVisitor<S, E>, Visitor: ::MapVisitor<D, E>,
>(&mut self, state: &mut S, mut visitor: Visitor) -> Result<Value, E> { >(&mut self, d: &mut D, mut visitor: Visitor) -> Result<Value, E> {
let mut values = TreeMap::new(); let mut values = TreeMap::new();
loop { loop {
match visitor.next(state) { match visitor.next(d) {
Some(Ok((key, value))) => { Some(Ok((key, value))) => {
values.insert(key, value); values.insert(key, value);
} }
@@ -413,19 +419,13 @@ mod json {
} }
} }
state.visit(&mut Visitor) d.visit(&mut Visitor)
} }
} }
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
trait Deserializer<S, E> {
fn deserialize<T: Deserialize<S, E>>(&mut self) -> Result<T, E>;
}
///////////////////////////////////////////////////////////////////////////////
enum Token { enum Token {
Null, Null,
Int(int), Int(int),
@@ -437,14 +437,14 @@ enum Token {
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
struct MyDeserializerState<Iter> { struct MyDeserializer<Iter> {
tokens: Iter, tokens: Iter,
peeked: Option<Token>, peeked: Option<Token>,
} }
impl<Iter: Iterator<Token>> MyDeserializerState<Iter> { impl<Iter: Iterator<Token>> MyDeserializer<Iter> {
fn new(tokens: Iter) -> MyDeserializerState<Iter> { fn new(tokens: Iter) -> MyDeserializer<Iter> {
MyDeserializerState { MyDeserializer {
tokens: tokens, tokens: tokens,
peeked: None, peeked: None,
} }
@@ -471,16 +471,16 @@ impl<Iter: Iterator<Token>> MyDeserializerState<Iter> {
impl< impl<
Iter: Iterator<Token>, Iter: Iterator<Token>,
> VisitorState< > DeserializerState<
(), (),
> for MyDeserializerState<Iter> { > for MyDeserializer<Iter> {
fn syntax_error(&mut self) -> () { fn syntax_error(&mut self) -> () {
() ()
} }
fn visit< fn visit<
V: Visitor<T, MyDeserializerState<Iter>, ()>, V: Visitor<T, MyDeserializer<Iter>, ()>,
T: Deserialize<MyDeserializerState<Iter>, ()>, T: Deserialize<MyDeserializer<Iter>, ()>,
>(&mut self, visitor: &mut V) -> Result<T, ()> { >(&mut self, visitor: &mut V) -> Result<T, ()> {
match self.next() { match self.next() {
Some(Null) => { Some(Null) => {
@@ -514,21 +514,21 @@ struct MySeqVisitor {
impl< impl<
Iter: Iterator<Token>, Iter: Iterator<Token>,
> SeqVisitor<MyDeserializerState<Iter>, ()> for MySeqVisitor { > SeqVisitor<MyDeserializer<Iter>, ()> for MySeqVisitor {
fn next< fn next<
T: Deserialize<MyDeserializerState<Iter>, ()>, T: Deserialize<MyDeserializer<Iter>, ()>,
>(&mut self, state: &mut MyDeserializerState<Iter>) -> Option<Result<T, ()>> { >(&mut self, d: &mut MyDeserializer<Iter>) -> Option<Result<T, ()>> {
match state.peek() { match d.peek() {
Some(&End) => { Some(&End) => {
state.next(); d.next();
None None
} }
Some(_) => { Some(_) => {
self.len -= 1; self.len -= 1;
Some(Deserialize::deserialize(state)) Some(Deserialize::deserialize(d))
} }
None => { None => {
Some(Err(state.syntax_error())) Some(Err(d.syntax_error()))
} }
} }
} }
@@ -544,25 +544,25 @@ struct MyMapVisitor {
impl< impl<
Iter: Iterator<Token>, Iter: Iterator<Token>,
> MapVisitor<MyDeserializerState<Iter>, ()> for MyMapVisitor { > MapVisitor<MyDeserializer<Iter>, ()> for MyMapVisitor {
fn next< fn next<
K: Deserialize<MyDeserializerState<Iter>, ()>, K: Deserialize<MyDeserializer<Iter>, ()>,
V: Deserialize<MyDeserializerState<Iter>, ()>, V: Deserialize<MyDeserializer<Iter>, ()>,
>(&mut self, state: &mut MyDeserializerState<Iter>) -> Option<Result<(K, V), ()>> { >(&mut self, d: &mut MyDeserializer<Iter>) -> Option<Result<(K, V), ()>> {
match state.peek() { match d.peek() {
Some(&End) => { Some(&End) => {
state.next(); d.next();
None None
} }
Some(_) => { Some(_) => {
self.len -= 1; self.len -= 1;
let key = match Deserialize::deserialize(state) { let key = match Deserialize::deserialize(d) {
Ok(key) => key, Ok(key) => key,
Err(err) => { return Some(Err(err)); } Err(err) => { return Some(Err(err)); }
}; };
let value = match Deserialize::deserialize(state) { let value = match Deserialize::deserialize(d) {
Ok(value) => value, Ok(value) => value,
Err(err) => { return Some(Err(err)); } Err(err) => { return Some(Err(err)); }
}; };
@@ -570,7 +570,7 @@ impl<
Some(Ok((key, value))) Some(Ok((key, value)))
} }
None => { None => {
Some(Err(state.syntax_error())) Some(Err(d.syntax_error()))
} }
} }
} }
@@ -589,7 +589,7 @@ fn main() {
Int(2), Int(2),
End End
); );
let mut state = MyDeserializerState::new(tokens.move_iter()); let mut state = MyDeserializer::new(tokens.move_iter());
let v: Result<Vec<int>, ()> = Deserialize::deserialize(&mut state); let v: Result<Vec<int>, ()> = Deserialize::deserialize(&mut state);
println!("{}", v); println!("{}", v);
@@ -602,7 +602,7 @@ fn main() {
Int(2), Int(2),
End End
); );
let mut state = MyDeserializerState::new(tokens.move_iter()); let mut state = MyDeserializer::new(tokens.move_iter());
let v: Result<(int, int), ()> = Deserialize::deserialize(&mut state); let v: Result<(int, int), ()> = Deserialize::deserialize(&mut state);
println!("{}", v); println!("{}", v);
@@ -615,7 +615,7 @@ fn main() {
Int(2), Int(2),
End End
); );
let mut state = MyDeserializerState::new(tokens.move_iter()); let mut state = MyDeserializer::new(tokens.move_iter());
let v: Result<json::Value, ()> = Deserialize::deserialize(&mut state); let v: Result<json::Value, ()> = Deserialize::deserialize(&mut state);
println!("{}", v); println!("{}", v);
@@ -630,7 +630,7 @@ fn main() {
Int(2), Int(2),
End End
); );
let mut state = MyDeserializerState::new(tokens.move_iter()); let mut state = MyDeserializer::new(tokens.move_iter());
let v: Result<HashMap<String, int>, ()> = Deserialize::deserialize(&mut state); let v: Result<HashMap<String, int>, ()> = Deserialize::deserialize(&mut state);
println!("{}", v); println!("{}", v);
@@ -645,7 +645,7 @@ fn main() {
Int(2), Int(2),
End End
); );
let mut state = MyDeserializerState::new(tokens.move_iter()); let mut state = MyDeserializer::new(tokens.move_iter());
let v: Result<json::Value, ()> = Deserialize::deserialize(&mut state); let v: Result<json::Value, ()> = Deserialize::deserialize(&mut state);
println!("{}", v); println!("{}", v);