fastvec/
serde.rs

1use alloc::format;
2use core::marker::PhantomData;
3use serde_core::de::{self, SeqAccess, Visitor};
4use serde_core::ser::SerializeSeq;
5use serde_core::{Deserialize, Deserializer, Serialize, Serializer};
6
7#[cfg(feature = "arrayvec")]
8use crate::ArrayVec;
9
10#[cfg(feature = "fastvec")]
11use crate::FastVec;
12
13#[cfg(feature = "smallvec")]
14use crate::SmallVec;
15
16#[cfg(all(feature = "arrayvec", feature = "serde"))]
17impl<T: Serialize, const N: usize> Serialize for ArrayVec<T, N> {
18    /// Serialize a [`ArrayVec`] as a sequence.
19    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
20    where
21        S: Serializer,
22    {
23        let mut seq = serializer.serialize_seq(Some(self.len()))?;
24        for element in self {
25            seq.serialize_element(element)?;
26        }
27        seq.end()
28    }
29}
30
31#[cfg(all(feature = "fastvec", feature = "serde"))]
32impl<T: Serialize, const N: usize> Serialize for FastVec<T, N> {
33    /// Serialize a [`FastVec`] as a sequence.
34    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
35    where
36        S: Serializer,
37    {
38        let mut seq = serializer.serialize_seq(Some(self.len()))?;
39        for element in self {
40            seq.serialize_element(element)?;
41        }
42        seq.end()
43    }
44}
45
46#[cfg(all(feature = "smallvec", feature = "serde"))]
47impl<T: Serialize, const N: usize> Serialize for SmallVec<T, N> {
48    /// Serialize an [`SmallVec`] as a sequence.
49    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
50    where
51        S: Serializer,
52    {
53        let mut seq = serializer.serialize_seq(Some(self.len()))?;
54        for element in self {
55            seq.serialize_element(element)?;
56        }
57        seq.end()
58    }
59}
60
61#[cfg(all(feature = "arrayvec", feature = "serde"))]
62impl<'de, T: Deserialize<'de>, const N: usize> Deserialize<'de> for ArrayVec<T, N> {
63    /// Deserialize a [`ArrayVec`] from a sequence.
64    ///
65    /// # Panics
66    /// Panics if the sequence length exceeds the inline capacity `N`.
67    #[inline]
68    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
69    where
70        D: Deserializer<'de>,
71    {
72        struct ArrayVecVisitor<T, const N: usize> {
73            _marker: PhantomData<T>,
74        }
75
76        impl<'de, T: Deserialize<'de>, const N: usize> Visitor<'de> for ArrayVecVisitor<T, N> {
77            type Value = ArrayVec<T, N>;
78
79            fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
80                formatter.write_str("a sequence")
81            }
82
83            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
84            where
85                A: SeqAccess<'de>,
86            {
87                let mut vec = ArrayVec::new();
88
89                while let Some(element) = seq.next_element()? {
90                    if vec.len() < N {
91                        vec.push(element);
92                    } else {
93                        return Err(de::Error::custom(format!(
94                            "ArrayVec inline capacity {} exceeded while deserializing sequence",
95                            N
96                        )));
97                    }
98                }
99
100                Ok(vec)
101            }
102        }
103
104        deserializer.deserialize_seq(ArrayVecVisitor {
105            _marker: PhantomData,
106        })
107    }
108}
109
110#[cfg(all(feature = "fastvec", feature = "serde"))]
111impl<'de, T: Deserialize<'de>, const N: usize> Deserialize<'de> for FastVec<T, N> {
112    /// Deserialize an [`FastVec`] from a sequence.
113    ///
114    /// If the sequence length exceeds the inline capacity `N`, the data will be stored on the heap.
115    #[inline]
116    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
117    where
118        D: Deserializer<'de>,
119    {
120        struct FastVecVisitor<T, const N: usize> {
121            _marker: PhantomData<T>,
122        }
123
124        impl<'de, T: Deserialize<'de>, const N: usize> Visitor<'de> for FastVecVisitor<T, N> {
125            type Value = FastVec<T, N>;
126
127            fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
128                formatter.write_str("a sequence")
129            }
130
131            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
132            where
133                A: SeqAccess<'de>,
134            {
135                let mut vec = match seq.size_hint() {
136                    Some(hint) => FastVec::with_capacity(hint),
137                    None => FastVec::new(),
138                };
139
140                let vec_mut = vec.data();
141
142                while let Some(element) = seq.next_element::<T>()? {
143                    vec_mut.push(element);
144                }
145
146                Ok(vec)
147            }
148        }
149
150        deserializer.deserialize_seq(FastVecVisitor {
151            _marker: PhantomData,
152        })
153    }
154}
155
156#[cfg(all(feature = "smallvec", feature = "serde"))]
157impl<'de, T: Deserialize<'de>, const N: usize> Deserialize<'de> for SmallVec<T, N> {
158    /// Deserialize an [`SmallVec`] from a sequence.
159    ///
160    /// If the sequence length exceeds the inline capacity `N`, the data will be stored on the heap.
161    #[inline]
162    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
163    where
164        D: Deserializer<'de>,
165    {
166        struct SmallVecVisitor<T, const N: usize> {
167            _marker: PhantomData<T>,
168        }
169
170        impl<'de, T: Deserialize<'de>, const N: usize> Visitor<'de> for SmallVecVisitor<T, N> {
171            type Value = SmallVec<T, N>;
172
173            fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
174                formatter.write_str("a sequence")
175            }
176
177            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
178            where
179                A: SeqAccess<'de>,
180            {
181                let mut vec = match seq.size_hint() {
182                    Some(hint) => SmallVec::with_capacity(hint),
183                    None => SmallVec::new(),
184                };
185
186                while let Some(element) = seq.next_element::<T>()? {
187                    vec.push(element);
188                }
189
190                Ok(vec)
191            }
192        }
193
194        deserializer.deserialize_seq(SmallVecVisitor {
195            _marker: PhantomData,
196        })
197    }
198}
fastvec/serde.rs

fastvec/
serde.rs
