1 use serde::de::{Deserialize, Error, SeqAccess, Visitor};
2 use serde::ser::{Serialize, SerializeSeq, Serializer};
3 use std::fmt;
4 use std::marker::PhantomData;
5 
6 /// Map to serializeable representation
7 pub trait IntoSerializable {
8     type Output;
into_serializable(self) -> Self::Output9     fn into_serializable(self) -> Self::Output;
10 }
11 
12 /// Map from deserialized representation
13 pub trait FromDeserialized: Sized {
14     type Input;
from_deserialized<E>(input: Self::Input) -> Result<Self, E> where E: Error15     fn from_deserialized<E>(input: Self::Input) -> Result<Self, E>
16     where
17         E: Error;
18 }
19 
20 /// Serde combinator. A sequence visitor that maps deserialized elements
21 /// lazily; the visitor can also emit new errors if the elements have errors.
22 pub struct MappedSequenceVisitor<T, R, F>
23 where
24     F: Fn(T) -> Result<R, &'static str>,
25 {
26     f: F,
27     marker: PhantomData<fn() -> T>,
28 }
29 
30 impl<'de, F, T, R> MappedSequenceVisitor<T, R, F>
31 where
32     T: Deserialize<'de>,
33     F: Fn(T) -> Result<R, &'static str>,
34 {
new(f: F) -> Self35     pub fn new(f: F) -> Self {
36         MappedSequenceVisitor {
37             f: f,
38             marker: PhantomData,
39         }
40     }
41 }
42 
43 impl<'de, F, T, R> Visitor<'de> for MappedSequenceVisitor<T, R, F>
44 where
45     T: Deserialize<'de>,
46     F: Fn(T) -> Result<R, &'static str>,
47 {
48     type Value = Vec<R>;
49 
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result50     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
51         write!(formatter, "a sequence")
52     }
visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error> where A: SeqAccess<'de>,53     fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
54     where
55         A: SeqAccess<'de>,
56     {
57         let mut v = Vec::new();
58         while let Some(elem) = seq.next_element()? {
59             match (self.f)(elem) {
60                 Err(s) => Err(<A::Error>::custom(s))?,
61                 Ok(x) => v.push(x),
62             }
63         }
64         Ok(v)
65     }
66 }
67 
68 pub trait CollectSeqWithLength: Serializer {
collect_seq_with_length<I>(self, length: usize, iterable: I) -> Result<Self::Ok, Self::Error> where I: IntoIterator, I::Item: Serialize,69     fn collect_seq_with_length<I>(self, length: usize, iterable: I) -> Result<Self::Ok, Self::Error>
70     where
71         I: IntoIterator,
72         I::Item: Serialize,
73     {
74         let mut count = 0;
75         let mut seq = self.serialize_seq(Some(length))?;
76         for element in iterable {
77             seq.serialize_element(&element)?;
78             count += 1;
79         }
80         debug_assert_eq!(length, count, "collect_seq_with_length: length mismatch!");
81         seq.end()
82     }
83 
collect_seq_exact<I>(self, iterable: I) -> Result<Self::Ok, Self::Error> where I: IntoIterator, I::Item: Serialize, I::IntoIter: ExactSizeIterator,84     fn collect_seq_exact<I>(self, iterable: I) -> Result<Self::Ok, Self::Error>
85     where
86         I: IntoIterator,
87         I::Item: Serialize,
88         I::IntoIter: ExactSizeIterator,
89     {
90         let iter = iterable.into_iter();
91         self.collect_seq_with_length(iter.len(), iter)
92     }
93 }
94 
95 impl<S> CollectSeqWithLength for S where S: Serializer {}
96