mirror of
https://github.com/serde-rs/serde.git
synced 2025-09-29 22:11:09 +00:00
Remove commented out code
This commit is contained in:
Erick Tryzelaar
parent
538fcf244f
commit
150ec0d2d7
@ -357,462 +357,3 @@ impl<
|
||||
d.visit(&mut Visitor)
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
trait Deserialize<S, E> {
|
||||
fn deserialize(state: &mut S) -> Result<Self, E>;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
trait Deserializer<S, E> {
|
||||
fn visit<R>(&mut self, state: &mut S) -> Result<(), E>;
|
||||
|
||||
fn syntax_error(&mut self) -> E;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/*
|
||||
trait DeserializerState<E> {
|
||||
fn syntax_error(&mut self) -> E;
|
||||
|
||||
fn visit<
|
||||
V: VisitorState<T, Self, E>,
|
||||
T: Deserialize<Self, E>,
|
||||
>(&mut self, visitor: &mut V) -> Result<T, E>;
|
||||
}
|
||||
|
||||
trait Visitor<R, E> {
|
||||
fn visit<S>(&mut self, state: &mut S) -> Result<(), E>;
|
||||
|
||||
fn size_hint(&self) -> (uint, Option<uint>);
|
||||
}
|
||||
*/
|
||||
|
||||
trait VisitorState<
|
||||
D: Deserializer<Self, E>,
|
||||
//R,
|
||||
E,
|
||||
> {
|
||||
/*
|
||||
fn visit_null(&mut self) -> R;
|
||||
*/
|
||||
|
||||
fn visit_int(&mut self, d: &mut D, v: int) -> Result<int, E> {
|
||||
Err(d.syntax_error())
|
||||
//self.visit_i64(d, v as i64)
|
||||
}
|
||||
|
||||
/*
|
||||
fn visit_i8(&mut self, d: &mut D, v: i8) -> Result<(), E> {
|
||||
self.visit_i64(d, v as i64)
|
||||
}
|
||||
|
||||
fn visit_i16(&mut self, d: &mut D, v: i16) -> Result<(), E> {
|
||||
self.visit_i64(d, v as i64)
|
||||
}
|
||||
|
||||
fn visit_i32(&mut self, d: &mut D, v: i32) -> Result<(), E> {
|
||||
self.visit_i64(d, v as i64)
|
||||
}
|
||||
|
||||
fn visit_i64(&mut self, d: &mut D, v: i64) -> Result<(), E> {
|
||||
Err(d.syntax_error())
|
||||
}
|
||||
|
||||
fn visit_uint(&mut self, d: &mut D, v: int) -> Result<(), E> {
|
||||
self.visit_u64(d, v as u64)
|
||||
}
|
||||
|
||||
fn visit_u8(&mut self, d: &mut D, v: u8) -> Result<(), E> {
|
||||
self.visit_u64(d, v as u64)
|
||||
}
|
||||
|
||||
fn visit_u16(&mut self, d: &mut D, v: u16) -> Result<(), E> {
|
||||
self.visit_u64(d, v as u64)
|
||||
}
|
||||
|
||||
fn visit_u32(&mut self, d: &mut D, v: u32) -> Result<(), E> {
|
||||
self.visit_u64(d, v as u64)
|
||||
}
|
||||
|
||||
fn visit_u64(&mut self, d: &mut D, _v: u64) -> Result<(), E> {
|
||||
Err(d.syntax_error())
|
||||
}
|
||||
|
||||
fn visit_string(&mut self, d: &mut D, _v: String) -> Result<(), E> {
|
||||
Err(d.syntax_error())
|
||||
}
|
||||
*/
|
||||
|
||||
fn visit_seq<
|
||||
R,
|
||||
V: SeqVisitor<D, E>,
|
||||
>(&mut self, d: &mut D, _visitor: V) -> Result<(), E> {
|
||||
Err(d.syntax_error())
|
||||
}
|
||||
|
||||
/*
|
||||
/*
|
||||
#[inline]
|
||||
fn visit_named_seq<
|
||||
Elt: Deserialize<D, E>,
|
||||
V: SeqVisitor<D, Result<Elt, E>>,
|
||||
>(&mut self, d: &mut D, _name: &str, visitor: V) -> Result<T, E> {
|
||||
self.visit_seq(d, visitor)
|
||||
}
|
||||
*/
|
||||
|
||||
fn visit_seq_elt<
|
||||
T: Deserialize<Self, R>,
|
||||
>(&mut self, first: bool, value: T) -> R;
|
||||
*/
|
||||
|
||||
/*
|
||||
#[inline]
|
||||
fn visit_map<
|
||||
K: Deserialize<D, E>,
|
||||
V: Deserialize<D, E>,
|
||||
V: Visitor<D, Result<T, E>>,
|
||||
>(&mut self, d: &mut D, _visitor: V) -> Result<T, E> {
|
||||
Err(d.syntax_error())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn visit_named_map<
|
||||
V: Visitor<D, E>,
|
||||
>(&mut self, d: &mut D, _name: &str, visitor: V) -> Result<T, E> {
|
||||
self.visit_map(d, visitor)
|
||||
}
|
||||
|
||||
fn visit_map_elt<
|
||||
K: Deserialize<D, E>,
|
||||
V: Deserialize<D, E>,
|
||||
>(&mut self, first: bool, value: T) -> Result<(K, V), E>;
|
||||
*/
|
||||
}
|
||||
|
||||
trait SeqVisitor<D, E> {
|
||||
fn next<
|
||||
T: Deserialize<D, E>,
|
||||
>(&mut self, d: &mut D) -> Option<Result<T, E>>;
|
||||
|
||||
#[inline]
|
||||
fn size_hint(&self) -> (uint, Option<uint>) {
|
||||
(0, None)
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
trait MapVisitor<D, E> {
|
||||
fn next<
|
||||
K: Deserialize<D, E>,
|
||||
V: Deserialize<D, E>,
|
||||
>(&mut self, d: &mut D) -> Option<Result<(K, V), E>>;
|
||||
|
||||
#[inline]
|
||||
fn size_hint(&self) -> (uint, Option<uint>) {
|
||||
(0, None)
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/*
|
||||
macro_rules! impl_deserialize {
|
||||
($ty:ty, $method:ident) => {
|
||||
impl<
|
||||
S: Deserializer<E>,
|
||||
E,
|
||||
> Deserialize<S, E> for $ty {
|
||||
#[inline]
|
||||
fn deserialize(state: &mut S) -> Result<$ty, E> {
|
||||
struct Visitor;
|
||||
|
||||
impl<
|
||||
D: Deserializer<$ty, E>,
|
||||
E,
|
||||
> VisitorState<S, $ty, E> for Visitor {
|
||||
fn visit_int(&mut self, _d: &mut D, v: int) -> Result<$ty, E> {
|
||||
Ok(v)
|
||||
}
|
||||
}
|
||||
|
||||
state.visit(&mut Visitor)
|
||||
|
||||
|
||||
d.$method(token)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
impl<
|
||||
D: Deserializer<int, E>,
|
||||
E,
|
||||
> Deserialize<D, E> for int {
|
||||
fn deserialize(state: &mut D) -> Result<int, E> {
|
||||
struct Visitor;
|
||||
|
||||
impl<
|
||||
D: Deserializer<Visitor, E>,
|
||||
E,
|
||||
> VisitorState<D, E> for Visitor {
|
||||
fn visit_int(&mut self, _state: &mut D, v: int) -> Result<int, E> {
|
||||
Ok(v)
|
||||
}
|
||||
}
|
||||
|
||||
state.visit(&mut Visitor)
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
impl<
|
||||
S: Deserializer<String, E>,
|
||||
E,
|
||||
> Deserialize<S, E> for String {
|
||||
fn deserialize(state: &mut S) -> Result<String, E> {
|
||||
struct Visitor;
|
||||
|
||||
impl<
|
||||
D: Deserializer<String, E>,
|
||||
E,
|
||||
> VisitorState<S, String, E> for Visitor {
|
||||
fn visit_string(&mut self, _d: &mut D, v: String) -> Result<String, E> {
|
||||
Ok(v)
|
||||
}
|
||||
}
|
||||
|
||||
state.visit(&mut Visitor)
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/*
|
||||
impl<
|
||||
T: Deserialize<D, E>,
|
||||
D: Deserializer<Vec<T>, E>,
|
||||
E,
|
||||
> Deserialize<D, E> for Vec<T> {
|
||||
fn deserialize(d: &mut D) -> Result<Vec<T>, E> {
|
||||
struct Visitor;
|
||||
|
||||
impl<
|
||||
D: Deserializer<Visitor, E>,
|
||||
T: Deserialize<D, E>,
|
||||
E,
|
||||
> VisitorState<D, E> for Visitor {
|
||||
fn visit_seq<
|
||||
V: SeqVisitor<D, E>,
|
||||
>(&mut self, state: &mut D, mut visitor: V) -> Result<Vec<T>, E> {
|
||||
let (len, _) = visitor.size_hint();
|
||||
let mut values = Vec::with_capacity(len);
|
||||
|
||||
loop {
|
||||
match visitor.next(state) {
|
||||
Some(Ok(value)) => {
|
||||
values.push(value);
|
||||
}
|
||||
Some(Err(err)) => {
|
||||
return Err(err);
|
||||
}
|
||||
None => {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(values)
|
||||
}
|
||||
}
|
||||
|
||||
d.visit(&mut Visitor)
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
impl<
|
||||
D: DeserializerState<E>,
|
||||
E
|
||||
> Deserialize<D, E> for () {
|
||||
fn deserialize(d: &mut D) -> Result<(), E> {
|
||||
struct Visitor;
|
||||
|
||||
impl<
|
||||
D: DeserializerState<E>,
|
||||
E,
|
||||
> ::VisitorState<(), D, E> for Visitor {
|
||||
fn visit_null(&mut self, _d: &mut D) -> Result<(), E> {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
d.visit(&mut Visitor)
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
impl<
|
||||
T0: Deserialize<D, E>,
|
||||
T1: Deserialize<D, E>,
|
||||
D: DeserializerState<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: DeserializerState<E>,
|
||||
E
|
||||
> ::VisitorState<(T0, T1), D, E> for Visitor {
|
||||
fn visit_seq<
|
||||
Visitor: ::SeqVisitor<D, E>,
|
||||
>(&mut self, d: &mut D, mut visitor: Visitor) -> Result<(T0, T1), E> {
|
||||
let mut state = 0u;
|
||||
let mut t0 = None;
|
||||
let mut t1 = None;
|
||||
|
||||
loop {
|
||||
match state {
|
||||
0 => {
|
||||
t0 = match visitor.next(d) {
|
||||
Some(Ok(v)) => Some(v),
|
||||
Some(Err(err)) => { return Err(err); }
|
||||
None => { return Err(d.syntax_error()); }
|
||||
};
|
||||
state += 1;
|
||||
}
|
||||
1 => {
|
||||
t1 = match visitor.next(d) {
|
||||
Some(Ok(v)) => Some(v),
|
||||
Some(Err(err)) => { return Err(err); }
|
||||
None => { return Err(d.syntax_error()); }
|
||||
};
|
||||
state += 1;
|
||||
}
|
||||
_ => {
|
||||
match visitor.next(d) {
|
||||
Some(Ok(())) => { return Err(d.syntax_error()); }
|
||||
Some(Err(err)) => { return Err(err); }
|
||||
None => { break; }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
match (t0, t1) {
|
||||
(Some(t0), Some(t1)) => Ok((t0, t1)),
|
||||
_ => Err(d.syntax_error()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
d.visit(&mut Visitor)
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
impl<
|
||||
K: Deserialize<D, E> + Eq + Hash,
|
||||
V: Deserialize<D, E>,
|
||||
D: DeserializerState<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: DeserializerState<E>,
|
||||
E,
|
||||
> ::VisitorState<HashMap<K, V>, D, 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();
|
||||
let mut values = HashMap::with_capacity(len);
|
||||
|
||||
loop {
|
||||
let kv: Option<Result<(K, V), E>> = visitor.next(d);
|
||||
match kv {
|
||||
Some(Ok((key, value))) => {
|
||||
values.insert(key, value);
|
||||
}
|
||||
Some(Err(err)) => {
|
||||
return Err(err);
|
||||
}
|
||||
None => {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(values)
|
||||
}
|
||||
}
|
||||
|
||||
d.visit(&mut Visitor)
|
||||
}
|
||||
}
|
||||
|
||||
impl<
|
||||
K: Deserialize<D, E> + Eq + Ord,
|
||||
V: Deserialize<D, E>,
|
||||
D: DeserializerState<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: DeserializerState<E>,
|
||||
E,
|
||||
> ::VisitorState<TreeMap<K, V>, D, 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 {
|
||||
let kv: Option<Result<(K, V), E>> = visitor.next(d);
|
||||
match kv {
|
||||
Some(Ok((key, value))) => {
|
||||
values.insert(key, value);
|
||||
}
|
||||
Some(Err(err)) => {
|
||||
return Err(err);
|
||||
}
|
||||
None => {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(values)
|
||||
}
|
||||
}
|
||||
|
||||
d.visit(&mut Visitor)
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
*/
|
||||
*/
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user