serde_bytes/
de.rs

1use crate::{ByteArray, Bytes};
2use core::fmt;
3use core::marker::PhantomData;
4use serde::de::{Error, Visitor};
5use serde::Deserializer;
6
7#[cfg(any(feature = "std", feature = "alloc"))]
8use crate::ByteBuf;
9
10#[cfg(any(feature = "std", feature = "alloc"))]
11use core::cmp;
12
13#[cfg(feature = "alloc")]
14use alloc::borrow::Cow;
15#[cfg(all(feature = "std", not(feature = "alloc")))]
16use std::borrow::Cow;
17
18#[cfg(feature = "alloc")]
19use alloc::boxed::Box;
20#[cfg(feature = "alloc")]
21use alloc::string::String;
22#[cfg(feature = "alloc")]
23use alloc::vec::Vec;
24
25#[cfg(any(feature = "std", feature = "alloc"))]
26use serde::de::SeqAccess;
27
28/// Types that can be deserialized via `#[serde(with = "serde_bytes")]`.
29pub trait Deserialize<'de>: Sized {
30    #[allow(missing_docs)]
31    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
32    where
33        D: Deserializer<'de>;
34}
35
36impl<'de: 'a, 'a> Deserialize<'de> for &'a [u8] {
37    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
38    where
39        D: Deserializer<'de>,
40    {
41        // serde::Deserialize for &[u8] is already optimized, so simply forward to that.
42        serde::Deserialize::deserialize(deserializer)
43    }
44}
45
46#[cfg(any(feature = "std", feature = "alloc"))]
47impl<'de> Deserialize<'de> for Vec<u8> {
48    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
49    where
50        D: Deserializer<'de>,
51    {
52        Deserialize::deserialize(deserializer).map(ByteBuf::into_vec)
53    }
54}
55
56impl<'de: 'a, 'a> Deserialize<'de> for &'a Bytes {
57    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
58    where
59        D: Deserializer<'de>,
60    {
61        // serde::Deserialize for &[u8] is already optimized, so simply forward to that.
62        serde::Deserialize::deserialize(deserializer).map(Bytes::new)
63    }
64}
65
66impl<'de, const N: usize> Deserialize<'de> for [u8; N] {
67    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
68    where
69        D: Deserializer<'de>,
70    {
71        let arr: ByteArray<N> = serde::Deserialize::deserialize(deserializer)?;
72        Ok(*arr)
73    }
74}
75
76impl<'de, const N: usize> Deserialize<'de> for &'de [u8; N] {
77    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
78    where
79        D: Deserializer<'de>,
80    {
81        let arr: &ByteArray<N> = serde::Deserialize::deserialize(deserializer)?;
82        Ok(arr)
83    }
84}
85
86impl<'de, const N: usize> Deserialize<'de> for ByteArray<N> {
87    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
88    where
89        D: Deserializer<'de>,
90    {
91        // Via the serde::Deserialize impl for ByteArray.
92        serde::Deserialize::deserialize(deserializer)
93    }
94}
95
96impl<'de: 'a, 'a, const N: usize> Deserialize<'de> for &'a ByteArray<N> {
97    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
98    where
99        D: Deserializer<'de>,
100    {
101        // Via the serde::Deserialize impl for &ByteArray.
102        serde::Deserialize::deserialize(deserializer)
103    }
104}
105
106#[cfg(any(feature = "std", feature = "alloc"))]
107impl<'de> Deserialize<'de> for ByteBuf {
108    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
109    where
110        D: Deserializer<'de>,
111    {
112        // Via the serde::Deserialize impl for ByteBuf.
113        serde::Deserialize::deserialize(deserializer)
114    }
115}
116
117#[cfg(any(feature = "std", feature = "alloc"))]
118impl<'de: 'a, 'a> Deserialize<'de> for Cow<'a, [u8]> {
119    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
120    where
121        D: Deserializer<'de>,
122    {
123        struct CowVisitor;
124
125        impl<'de> Visitor<'de> for CowVisitor {
126            type Value = Cow<'de, [u8]>;
127
128            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
129                formatter.write_str("a byte array")
130            }
131
132            fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
133            where
134                E: Error,
135            {
136                Ok(Cow::Borrowed(v))
137            }
138
139            fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
140            where
141                E: Error,
142            {
143                Ok(Cow::Borrowed(v.as_bytes()))
144            }
145
146            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
147            where
148                E: Error,
149            {
150                Ok(Cow::Owned(v.to_vec()))
151            }
152
153            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
154            where
155                E: Error,
156            {
157                Ok(Cow::Owned(v.as_bytes().to_vec()))
158            }
159
160            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
161            where
162                E: Error,
163            {
164                Ok(Cow::Owned(v))
165            }
166
167            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
168            where
169                E: Error,
170            {
171                Ok(Cow::Owned(v.into_bytes()))
172            }
173
174            fn visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
175            where
176                V: SeqAccess<'de>,
177            {
178                let len = cmp::min(visitor.size_hint().unwrap_or(0), 4096);
179                let mut bytes = Vec::with_capacity(len);
180
181                while let Some(b) = visitor.next_element()? {
182                    bytes.push(b);
183                }
184
185                Ok(Cow::Owned(bytes))
186            }
187        }
188
189        deserializer.deserialize_bytes(CowVisitor)
190    }
191}
192
193#[cfg(any(feature = "std", feature = "alloc"))]
194impl<'de: 'a, 'a> Deserialize<'de> for Cow<'a, Bytes> {
195    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
196    where
197        D: Deserializer<'de>,
198    {
199        let cow: Cow<[u8]> = Deserialize::deserialize(deserializer)?;
200        match cow {
201            Cow::Borrowed(bytes) => Ok(Cow::Borrowed(Bytes::new(bytes))),
202            Cow::Owned(bytes) => Ok(Cow::Owned(ByteBuf::from(bytes))),
203        }
204    }
205}
206
207#[cfg(any(feature = "std", feature = "alloc"))]
208impl<'de> Deserialize<'de> for Box<[u8]> {
209    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
210    where
211        D: Deserializer<'de>,
212    {
213        Deserialize::deserialize(deserializer).map(Vec::into_boxed_slice)
214    }
215}
216
217#[cfg(any(feature = "std", feature = "alloc"))]
218impl<'de> Deserialize<'de> for Box<Bytes> {
219    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
220    where
221        D: Deserializer<'de>,
222    {
223        let bytes: Box<[u8]> = Deserialize::deserialize(deserializer)?;
224        Ok(bytes.into())
225    }
226}
227
228impl<'de, T> Deserialize<'de> for Option<T>
229where
230    T: Deserialize<'de>,
231{
232    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
233    where
234        D: Deserializer<'de>,
235    {
236        struct BytesVisitor<T> {
237            out: PhantomData<T>,
238        }
239
240        impl<'de, T> Visitor<'de> for BytesVisitor<T>
241        where
242            T: Deserialize<'de>,
243        {
244            type Value = Option<T>;
245
246            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
247                f.write_str("optional byte array")
248            }
249
250            fn visit_unit<E: Error>(self) -> Result<Self::Value, E> {
251                Ok(None)
252            }
253
254            fn visit_none<E: Error>(self) -> Result<Self::Value, E> {
255                Ok(None)
256            }
257
258            fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
259            where
260                D: Deserializer<'de>,
261            {
262                T::deserialize(deserializer).map(Some)
263            }
264        }
265
266        let visitor = BytesVisitor { out: PhantomData };
267        deserializer.deserialize_option(visitor)
268    }
269}
serde_bytes/de.rs

serde_bytes/
de.rs
