xmlity/types/
iterator.rs

1//! This module contains visitors and [`Serialize`]/[`Deserialize`] implementations for iterators and common collections.
2use std::collections::{BTreeSet, HashMap, HashSet, LinkedList, VecDeque};
3use std::marker::PhantomData;
4
5use crate::de::{self, Visitor};
6use crate::ser::SerializeSeq;
7use crate::{de::SeqAccess, Deserialize, Deserializer};
8use crate::{Serialize, Serializer};
9use core::fmt;
10use std::iter::FromIterator;
11
12use super::utils::ValueOrWhitespace;
13
14/// This trait is used to decide how [`IteratorVisitor`] will deserialize a type.
15pub trait IteratorVisitorMiddleware<T> {
16    /// The output of the middleware.
17    type Output;
18
19    /// Takes in the item iterator and results in the [`IteratorVisitorMiddleware::Output`] type.
20    fn transform<I>(iter: I) -> Self::Output
21    where
22        I: IntoIterator<Item = T>;
23}
24
25impl<T, F: FromIterator<T>> IteratorVisitorMiddleware<T> for F {
26    type Output = F;
27    fn transform<I>(iter: I) -> Self::Output
28    where
29        I: IntoIterator<Item = T>,
30    {
31        F::from_iter(iter)
32    }
33}
34
35struct NoWhitespaceIter<T, O> {
36    _marker: PhantomData<(T, O)>,
37    result: O,
38}
39
40impl<'de, T: Deserialize<'de>, O: FromIterator<T>> FromIterator<ValueOrWhitespace<'de, T>>
41    for NoWhitespaceIter<T, O>
42{
43    fn from_iter<I: IntoIterator<Item = ValueOrWhitespace<'de, T>>>(iter: I) -> Self {
44        Self {
45            _marker: PhantomData,
46            result: O::from_iter(iter.into_iter().filter_map(|a| match a {
47                ValueOrWhitespace::Whitespace(_) => None,
48                ValueOrWhitespace::Value(a) => Some(a),
49            })),
50        }
51    }
52}
53
54impl<'de, T: Deserialize<'de>, O: FromIterator<T>> Deserialize<'de> for NoWhitespaceIter<T, O> {
55    fn deserialize<D: Deserializer<'de>>(reader: D) -> Result<Self, D::Error> {
56        reader.deserialize_seq(IteratorVisitor::<_, Self>::default())
57    }
58}
59
60/// This visitor allows for deserializing an iterator of elements, which can be useful for deserializing sequences of elements into a collection/single value.
61pub struct IteratorVisitor<T, M> {
62    _marker: PhantomData<(T, M)>,
63}
64
65impl<T, M: IteratorVisitorMiddleware<T>> IteratorVisitor<T, M> {
66    /// Creates a new [`IteratorVisitor`].
67    pub fn new() -> Self {
68        Self {
69            _marker: PhantomData,
70        }
71    }
72}
73
74impl<T, M: IteratorVisitorMiddleware<T>> Default for IteratorVisitor<T, M> {
75    fn default() -> Self {
76        Self::new()
77    }
78}
79
80impl<'de, T, M> Visitor<'de> for IteratorVisitor<T, M>
81where
82    T: Deserialize<'de>,
83    M: IteratorVisitorMiddleware<T>,
84    M::Output: de::Deserialize<'de>,
85{
86    type Value = M::Output;
87
88    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
89        write!(formatter, "a sequence of elements")
90    }
91
92    fn visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error>
93    where
94        S: SeqAccess<'de>,
95    {
96        Ok(M::transform(std::iter::from_fn(|| {
97            seq.next_element_seq::<T>().ok().flatten()
98        })))
99    }
100}
101
102fn serialize_seq<T, S>(iter: T, serializer: S) -> Result<S::Ok, S::Error>
103where
104    T: IntoIterator,
105    T::Item: Serialize,
106    S: Serializer,
107{
108    let mut seq = serializer.serialize_seq()?;
109    for element in iter {
110        seq.serialize_element(&element)?;
111    }
112    seq.end()
113}
114
115impl<T: Serialize> Serialize for &[T] {
116    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
117        let mut seq = serializer.serialize_seq()?;
118        for item in self.iter() {
119            seq.serialize_element(item)?;
120        }
121
122        seq.end()
123    }
124}
125
126// Array
127impl<'de, const N: usize, T: Deserialize<'de>> Deserialize<'de> for [T; N] {
128    fn deserialize<D: Deserializer<'de>>(reader: D) -> Result<Self, D::Error> {
129        struct LimitFromIter<const N: usize, T, O> {
130            _marker: PhantomData<(T, O)>,
131            result: O,
132        }
133
134        impl<'de, const N: usize, T: Deserialize<'de>, O: FromIterator<T>> FromIterator<T>
135            for LimitFromIter<N, T, O>
136        {
137            fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
138                Self {
139                    _marker: PhantomData,
140                    result: O::from_iter(iter.into_iter().take(N)),
141                }
142            }
143        }
144
145        impl<'de, const N: usize, T: Deserialize<'de>, O: FromIterator<T>> Deserialize<'de>
146            for LimitFromIter<N, T, O>
147        {
148            fn deserialize<D: Deserializer<'de>>(reader: D) -> Result<Self, D::Error> {
149                reader.deserialize_seq(IteratorVisitor::<_, Self>::default())
150            }
151        }
152
153        let vec = reader.deserialize_seq(IteratorVisitor::<
154            ValueOrWhitespace<T>,
155            NoWhitespaceIter<T, LimitFromIter<N, T, Vec<T>>>,
156        >::new())?;
157
158        vec.result
159            .result
160            .try_into()
161            .map_err(|_| de::Error::missing_data())
162    }
163}
164
165impl<const N: usize, T: Serialize> Serialize for [T; N] {
166    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
167        self.as_slice().serialize(serializer)
168    }
169}
170
171// Vec
172impl<'de, T: Deserialize<'de>> Deserialize<'de> for Vec<T> {
173    fn deserialize<D: Deserializer<'de>>(reader: D) -> Result<Self, D::Error> {
174        reader
175            .deserialize_seq(IteratorVisitor::<_, NoWhitespaceIter<_, Self>>::default())
176            .map(|a| a.result)
177    }
178}
179
180impl<T: Serialize> Serialize for Vec<T> {
181    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
182        self.as_slice().serialize(serializer)
183    }
184}
185
186// VecDeque
187impl<'de, T: Deserialize<'de>> Deserialize<'de> for VecDeque<T> {
188    fn deserialize<D: Deserializer<'de>>(reader: D) -> Result<Self, D::Error> {
189        reader
190            .deserialize_seq(IteratorVisitor::<_, NoWhitespaceIter<_, Self>>::default())
191            .map(|a| a.result)
192    }
193}
194
195impl<T: Serialize> Serialize for VecDeque<T> {
196    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
197        self.as_slices().0.serialize(serializer)
198    }
199}
200
201// LinkedList
202impl<'de, T: Deserialize<'de>> Deserialize<'de> for LinkedList<T> {
203    fn deserialize<D: Deserializer<'de>>(reader: D) -> Result<Self, D::Error> {
204        reader
205            .deserialize_seq(IteratorVisitor::<_, NoWhitespaceIter<_, Self>>::default())
206            .map(|a| a.result)
207    }
208}
209
210impl<T: Serialize> Serialize for LinkedList<T> {
211    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
212        serialize_seq(self.iter(), serializer)
213    }
214}
215
216// HashSet
217impl<'de, T: Deserialize<'de> + Eq + std::hash::Hash> Deserialize<'de> for HashSet<T> {
218    fn deserialize<D: Deserializer<'de>>(reader: D) -> Result<Self, D::Error> {
219        reader
220            .deserialize_seq(IteratorVisitor::<_, NoWhitespaceIter<_, Self>>::default())
221            .map(|a| a.result)
222    }
223}
224
225impl<T: Serialize> Serialize for HashSet<T> {
226    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
227        serialize_seq(self.iter(), serializer)
228    }
229}
230
231// BTreeSet
232impl<'de, T: Deserialize<'de> + Ord> Deserialize<'de> for BTreeSet<T> {
233    fn deserialize<D: Deserializer<'de>>(reader: D) -> Result<Self, D::Error> {
234        reader
235            .deserialize_seq(IteratorVisitor::<_, NoWhitespaceIter<_, Self>>::default())
236            .map(|a| a.result)
237    }
238}
239
240impl<T: Serialize> Serialize for BTreeSet<T> {
241    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
242        serialize_seq(self.iter(), serializer)
243    }
244}
245
246// HashMap
247impl<'de, K: Deserialize<'de> + Eq + std::hash::Hash, V: Deserialize<'de>> Deserialize<'de>
248    for HashMap<K, V>
249{
250    fn deserialize<D: Deserializer<'de>>(reader: D) -> Result<Self, D::Error> {
251        reader
252            .deserialize_seq(IteratorVisitor::<_, NoWhitespaceIter<_, Self>>::default())
253            .map(|a| a.result)
254    }
255}
256
257impl<K: Serialize, V: Serialize> Serialize for HashMap<K, V> {
258    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
259        serialize_seq(self.iter(), serializer)
260    }
261}
xmlity/types/iterator.rs

xmlity/types/
iterator.rs
