serde_bytes/
de.rs

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

serde_bytes/
de.rs
