playing around with a de2 generic visitor
This commit is contained in:
Erick Tryzelaar
parent
c3a5becd22
commit
a3ac2ab061
@ -10,19 +10,25 @@ trait Deserialize<S, E> {
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
trait VisitorState<E> {
|
||||
fn visit<
|
||||
V: Visitor<Value, SeqValue, E>,
|
||||
Value,
|
||||
SeqValue,
|
||||
>(&mut self, visitor: &mut V) -> Result<Value, E>;
|
||||
|
||||
fn visit_null(&mut self) -> Result<(), E>;
|
||||
|
||||
fn visit_int(&mut self) -> Result<int, E>;
|
||||
|
||||
fn visit_string(&mut self) -> Result<String, E>;
|
||||
|
||||
fn visit_seq<
|
||||
T: Deserialize<Self, E>,
|
||||
V: Visitor<T, Self, E>
|
||||
>(&mut self) -> Result<T, E>;
|
||||
fn visit_seq(&mut self) -> Result<uint, E>;
|
||||
|
||||
fn visit_seq_elt<
|
||||
T: Deserialize<Self, E>,
|
||||
>(&mut self) -> Result<T, E>;
|
||||
>(&mut self) -> Option<Result<T, E>>;
|
||||
|
||||
/*
|
||||
fn visit_map<
|
||||
T: Deserialize<Self, E>,
|
||||
V: Visitor<T, Self, E>
|
||||
@ -32,8 +38,34 @@ trait VisitorState<E> {
|
||||
K: Deserialize<Self, E>,
|
||||
V: Deserialize<Self, E>
|
||||
>(&mut self) -> Result<(K, V), E>;
|
||||
*/
|
||||
}
|
||||
|
||||
trait Visitor<Value, SeqValue, E> {
|
||||
fn visit_null(&mut self) -> Result<Value, E>;
|
||||
|
||||
fn visit_int(&mut self, v: int) -> Result<Value, E>;
|
||||
|
||||
fn visit_string(&mut self, v: String) -> Result<Value, E>;
|
||||
|
||||
fn visit_seq(&mut self, len: uint) -> Result<SeqValue, E>;
|
||||
|
||||
fn visit_seq_elt(&mut self, values: &mut SeqValue, value: Value) -> Result<(), E>;
|
||||
|
||||
fn visit_seq_end(&mut self, values: SeqValue) -> Result<Value, E>;
|
||||
}
|
||||
|
||||
/*
|
||||
trait Visitor<VS: VisitorState<Self, E>, E> {
|
||||
fn next<
|
||||
T: Deserialize<VS, E>,
|
||||
>(&mut self) -> Option<Result<T, E>>;
|
||||
|
||||
fn size_hint(&self) -> (uint, Option<uint>);
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
trait Visitor<C, S, E> {
|
||||
fn new(len: uint) -> Self;
|
||||
|
||||
@ -41,16 +73,23 @@ trait Visitor<C, S, E> {
|
||||
|
||||
fn unwrap(self) -> Result<C, E>;
|
||||
}
|
||||
*/
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
impl<S: VisitorState<E>, E> Deserialize<S, E> for int {
|
||||
impl<
|
||||
S: VisitorState<E>,
|
||||
E,
|
||||
> Deserialize<S, E> for int {
|
||||
fn deserialize(state: &mut S) -> Result<int, E> {
|
||||
state.visit_int()
|
||||
}
|
||||
}
|
||||
|
||||
impl<S: VisitorState<E>, E> Deserialize<S, E> for String {
|
||||
impl<
|
||||
S: VisitorState<E>,
|
||||
E,
|
||||
> Deserialize<S, E> for String {
|
||||
fn deserialize(state: &mut S) -> Result<String, E> {
|
||||
state.visit_string()
|
||||
}
|
||||
@ -61,36 +100,33 @@ impl<S: VisitorState<E>, E> Deserialize<S, E> for String {
|
||||
impl<
|
||||
T: Deserialize<S, E>,
|
||||
S: VisitorState<E>,
|
||||
E
|
||||
E,
|
||||
> Deserialize<S, E> for Vec<T> {
|
||||
fn deserialize(state: &mut S) -> Result<Vec<T>, E> {
|
||||
struct Visitor<T> {
|
||||
value: Vec<T>,
|
||||
}
|
||||
let len = try!(state.visit_seq());
|
||||
let mut value = Vec::with_capacity(len);
|
||||
|
||||
impl<
|
||||
T: Deserialize<S, E>,
|
||||
S: VisitorState<E>,
|
||||
E
|
||||
> ::Visitor<Vec<T>, S, E> for Visitor<T> {
|
||||
fn new(len: uint) -> Visitor<T> {
|
||||
Visitor {
|
||||
value: Vec::with_capacity(len),
|
||||
}
|
||||
}
|
||||
|
||||
fn visit(&mut self, state: &mut S) -> Result<(), E> {
|
||||
let value = try!(state.visit_seq_elt());
|
||||
self.value.push(value);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn unwrap(self) -> Result<Vec<T>, E> {
|
||||
Ok(self.value)
|
||||
loop {
|
||||
match state.visit_seq_elt() {
|
||||
Some(Ok(v)) => { value.push(v); }
|
||||
Some(Err(err)) => { return Err(err); }
|
||||
None => { break; }
|
||||
}
|
||||
}
|
||||
|
||||
state.visit_seq::<Vec<T>, Visitor<T>>()
|
||||
Ok(value)
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
impl<
|
||||
S: VisitorState<E>,
|
||||
E
|
||||
> Deserialize<S, E> for () {
|
||||
fn deserialize(state: &mut S) -> Result<(), E> {
|
||||
state.visit_null()
|
||||
}
|
||||
}
|
||||
|
||||
@ -103,6 +139,29 @@ impl<
|
||||
E
|
||||
> Deserialize<S, E> for (T0, T1) {
|
||||
fn deserialize(state: &mut S) -> Result<(T0, T1), E> {
|
||||
let _ = try!(state.visit_seq());
|
||||
|
||||
let t0 = match state.visit_seq_elt() {
|
||||
Some(Ok(v)) => v,
|
||||
Some(Err(err)) => { return Err(err); }
|
||||
None => { fail!(); }
|
||||
};
|
||||
|
||||
let t1 = match state.visit_seq_elt() {
|
||||
Some(Ok(v)) => v,
|
||||
Some(Err(err)) => { return Err(err); }
|
||||
None => { fail!(); }
|
||||
};
|
||||
|
||||
match state.visit_seq_elt() {
|
||||
Some(Ok(())) => { fail!(); }
|
||||
Some(Err(err)) => { return Err(err); }
|
||||
None => { }
|
||||
}
|
||||
|
||||
Ok((t0, t1))
|
||||
|
||||
/*
|
||||
struct Visitor<T0, T1> {
|
||||
state: uint,
|
||||
t0: Option<T0>,
|
||||
@ -155,9 +214,11 @@ impl<
|
||||
}
|
||||
|
||||
state.visit_seq::<(T0, T1), Visitor<T0, T1>>()
|
||||
*/
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
impl<
|
||||
@ -197,6 +258,58 @@ impl<
|
||||
state.visit_map::<HashMap<K, V>, Visitor<K, V>>()
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
mod json {
|
||||
enum Value {
|
||||
Null,
|
||||
Bool(bool),
|
||||
Int(int),
|
||||
String(String),
|
||||
Vec(Vec<Value>),
|
||||
}
|
||||
|
||||
impl<
|
||||
S: super::VisitorState<E>,
|
||||
E
|
||||
> super::Deserialize<S, E> for Value {
|
||||
fn deserialize(state: &mut S) -> Result<Value, E> {
|
||||
struct Visitor;
|
||||
|
||||
impl<E> super::Visitor<Value, Vec<Value>, E> for Visitor {
|
||||
fn visit_null(&mut self) -> Result<Value, E> {
|
||||
Ok(Null)
|
||||
}
|
||||
|
||||
fn visit_int(&mut self, v: int) -> Result<Value, E> {
|
||||
Ok(Int(v))
|
||||
}
|
||||
|
||||
fn visit_string(&mut self, v: String) -> Result<Value, E> {
|
||||
Ok(String(v))
|
||||
}
|
||||
|
||||
fn visit_seq(&mut self, len: uint) -> Result<Vec<Value>, E> {
|
||||
Ok(Vec::with_capacity(len))
|
||||
}
|
||||
|
||||
fn visit_seq_elt(&mut self, values: &mut Vec<Value>, value: Value) -> Result<(), E> {
|
||||
values.push(value);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn visit_seq_end(&mut self, values: Vec<Value>) -> Result<Value, E> {
|
||||
Ok(Vec(values))
|
||||
}
|
||||
}
|
||||
|
||||
state.visit(&mut Visitor)
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
@ -207,6 +320,7 @@ trait Deserializer<S, E> {
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
enum Token {
|
||||
Null,
|
||||
Int(int),
|
||||
String(String),
|
||||
SeqStart(uint),
|
||||
@ -214,6 +328,8 @@ enum Token {
|
||||
End,
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
struct MyDeserializerState<Iter> {
|
||||
tokens: Iter,
|
||||
peeked: Option<Token>,
|
||||
@ -235,9 +351,79 @@ impl<Iter: Iterator<Token>> MyDeserializerState<Iter> {
|
||||
|
||||
self.tokens.next()
|
||||
}
|
||||
|
||||
fn peek<'a>(&'a mut self) -> Option<&'a Token> {
|
||||
match self.peeked {
|
||||
Some(_) => { }
|
||||
None => { self.peeked = self.tokens.next(); }
|
||||
}
|
||||
|
||||
self.peeked.as_ref()
|
||||
}
|
||||
}
|
||||
|
||||
impl<Iter: Iterator<Token>> VisitorState<()> for MyDeserializerState<Iter> {
|
||||
impl<
|
||||
'a,
|
||||
Iter: Iterator<Token>,
|
||||
> VisitorState<
|
||||
(),
|
||||
> for MyDeserializerState<Iter> {
|
||||
fn visit<
|
||||
V: Visitor<Value, SeqValue, ()>,
|
||||
Value,
|
||||
SeqValue,
|
||||
>(&mut self, visitor: &mut V) -> Result<Value, ()> {
|
||||
match self.next() {
|
||||
Some(Null) => {
|
||||
visitor.visit_null()
|
||||
}
|
||||
Some(Int(v)) => {
|
||||
visitor.visit_int(v)
|
||||
}
|
||||
Some(String(v)) => {
|
||||
visitor.visit_string(v)
|
||||
}
|
||||
Some(SeqStart(len)) => {
|
||||
let mut state = try!(visitor.visit_seq(len));
|
||||
|
||||
loop {
|
||||
match self.peek() {
|
||||
Some(&End) => {
|
||||
self.next();
|
||||
break;
|
||||
}
|
||||
Some(_) => {
|
||||
let value = try!(self.visit(visitor));
|
||||
try!(visitor.visit_seq_elt(&mut state, value));
|
||||
}
|
||||
None => {
|
||||
return Err(());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
visitor.visit_seq_end(state)
|
||||
}
|
||||
Some(MapStart(len)) => {
|
||||
Err(())
|
||||
}
|
||||
Some(End) => {
|
||||
Err(())
|
||||
}
|
||||
None => {
|
||||
Err(())
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
fn visit_null(&mut self) -> Result<(), ()> {
|
||||
match self.next() {
|
||||
Some(Null) => Ok(()),
|
||||
_ => Err(())
|
||||
}
|
||||
}
|
||||
|
||||
fn visit_int(&mut self) -> Result<int, ()> {
|
||||
match self.next() {
|
||||
Some(Int(v)) => Ok(v),
|
||||
@ -252,37 +438,31 @@ impl<Iter: Iterator<Token>> VisitorState<()> for MyDeserializerState<Iter> {
|
||||
}
|
||||
}
|
||||
|
||||
fn visit_seq<
|
||||
T: Deserialize<MyDeserializerState<Iter>, ()>,
|
||||
V: Visitor<T, MyDeserializerState<Iter>, ()>
|
||||
>(&mut self) -> Result<T, ()> {
|
||||
let len = match self.next() {
|
||||
Some(SeqStart(len)) => len,
|
||||
_ => { return Err(()); }
|
||||
};
|
||||
|
||||
let mut visitor: V = Visitor::new(len);
|
||||
|
||||
loop {
|
||||
match self.next() {
|
||||
Some(End) => { break; }
|
||||
Some(token) => {
|
||||
self.peeked = Some(token);
|
||||
try!(visitor.visit(self));
|
||||
}
|
||||
_ => { return Err(()); }
|
||||
}
|
||||
fn visit_seq(&mut self) -> Result<uint, ()> {
|
||||
match self.next() {
|
||||
Some(SeqStart(len)) => Ok(len),
|
||||
_ => Err(()),
|
||||
}
|
||||
|
||||
visitor.unwrap()
|
||||
}
|
||||
|
||||
fn visit_seq_elt<
|
||||
T: Deserialize<MyDeserializerState<Iter>, ()>,
|
||||
>(&mut self) -> Result<T, ()> {
|
||||
Deserialize::deserialize(self)
|
||||
>(&mut self) -> Option<Result<T, ()>> {
|
||||
match self.peek() {
|
||||
Some(&End) => {
|
||||
self.next();
|
||||
None
|
||||
}
|
||||
Some(_) => {
|
||||
Some(Deserialize::deserialize(self))
|
||||
}
|
||||
None => {
|
||||
Some(Err(()))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
fn visit_map<
|
||||
T: Deserialize<MyDeserializerState<Iter>, ()>,
|
||||
V: Visitor<T, MyDeserializerState<Iter>, ()>
|
||||
@ -316,6 +496,7 @@ impl<Iter: Iterator<Token>> VisitorState<()> for MyDeserializerState<Iter> {
|
||||
let v = try!(Deserialize::deserialize(self));
|
||||
Ok((k, v))
|
||||
}
|
||||
*/
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
@ -343,6 +524,7 @@ fn main() {
|
||||
let v: Result<(int, int), ()> = Deserialize::deserialize(&mut state);
|
||||
println!("{}", v);
|
||||
|
||||
/*
|
||||
let tokens = vec!(
|
||||
MapStart(2),
|
||||
String("a".to_string()),
|
||||
@ -355,4 +537,5 @@ fn main() {
|
||||
|
||||
let v: Result<HashMap<String, int>, ()> = Deserialize::deserialize(&mut state);
|
||||
println!("{}", v);
|
||||
*/
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user