/rust/registry/src/index.crates.io-6f17d22bba15001f/serde_bytes-0.11.17/src/de.rs

Source (jump to first uncovered line)
use crate::{ByteArray, Bytes};
use core::fmt;
use core::marker::PhantomData;
use serde::de::{Error, Visitor};
use serde::Deserializer;

#[cfg(any(feature = "std", feature = "alloc"))]
use crate::ByteBuf;

#[cfg(any(feature = "std", feature = "alloc"))]
use core::cmp;

#[cfg(feature = "alloc")]
use alloc::borrow::Cow;
#[cfg(all(feature = "std", not(feature = "alloc")))]
use std::borrow::Cow;

#[cfg(feature = "alloc")]
use alloc::boxed::Box;
#[cfg(feature = "alloc")]
use alloc::string::String;
#[cfg(feature = "alloc")]
use alloc::vec::Vec;

#[cfg(any(feature = "std", feature = "alloc"))]
use serde::de::SeqAccess;

/// Types that can be deserialized via `#[serde(with = "serde_bytes")]`.
pub trait Deserialize<'de>: Sized {
    #[allow(missing_docs)]
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>;
}

impl<'de: 'a, 'a> Deserialize<'de> for &'a [u8] {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        // serde::Deserialize for &[u8] is already optimized, so simply forward to that.
        serde::Deserialize::deserialize(deserializer)
    }
}

#[cfg(any(feature = "std", feature = "alloc"))]
impl<'de> Deserialize<'de> for Vec<u8> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        Deserialize::deserialize(deserializer).map(ByteBuf::into_vec)
    }
}

impl<'de: 'a, 'a> Deserialize<'de> for &'a Bytes {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        // serde::Deserialize for &[u8] is already optimized, so simply forward to that.
        serde::Deserialize::deserialize(deserializer).map(Bytes::new)
    }
}

impl<'de, const N: usize> Deserialize<'de> for [u8; N] {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let arr: ByteArray<N> = serde::Deserialize::deserialize(deserializer)?;
        Ok(*arr)
    }
}

impl<'de, const N: usize> Deserialize<'de> for &'de [u8; N] {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let arr: &ByteArray<N> = serde::Deserialize::deserialize(deserializer)?;
        Ok(arr)
    }
}

impl<'de, const N: usize> Deserialize<'de> for ByteArray<N> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        // Via the serde::Deserialize impl for ByteArray.
        serde::Deserialize::deserialize(deserializer)
    }
}

impl<'de: 'a, 'a, const N: usize> Deserialize<'de> for &'a ByteArray<N> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        // Via the serde::Deserialize impl for &ByteArray.
        serde::Deserialize::deserialize(deserializer)
    }
}

#[cfg(any(feature = "std", feature = "alloc"))]
impl<'de> Deserialize<'de> for ByteBuf {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        // Via the serde::Deserialize impl for ByteBuf.
        serde::Deserialize::deserialize(deserializer)
    }
}

#[cfg(any(feature = "std", feature = "alloc"))]
impl<'de: 'a, 'a> Deserialize<'de> for Cow<'a, [u8]> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct CowVisitor;

        impl<'de> Visitor<'de> for CowVisitor {
            type Value = Cow<'de, [u8]>;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("a byte array")
            }

            fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
            where
                E: Error,
            {
                Ok(Cow::Borrowed(v))
            }

            fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
            where
                E: Error,
            {
                Ok(Cow::Borrowed(v.as_bytes()))
            }

            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
            where
                E: Error,
            {
                Ok(Cow::Owned(v.to_vec()))
            }

            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
            where
                E: Error,
            {
                Ok(Cow::Owned(v.as_bytes().to_vec()))
            }

            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
            where
                E: Error,
            {
                Ok(Cow::Owned(v))
            }

            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
            where
                E: Error,
            {
                Ok(Cow::Owned(v.into_bytes()))
            }

            fn visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
            where
                V: SeqAccess<'de>,
            {
                let len = cmp::min(visitor.size_hint().unwrap_or(0), 4096);
                let mut bytes = Vec::with_capacity(len);

                while let Some(b) = visitor.next_element()? {
                    bytes.push(b);
                }

                Ok(Cow::Owned(bytes))
            }
        }

        deserializer.deserialize_bytes(CowVisitor)
    }
}

#[cfg(any(feature = "std", feature = "alloc"))]
impl<'de: 'a, 'a> Deserialize<'de> for Cow<'a, Bytes> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let cow: Cow<[u8]> = Deserialize::deserialize(deserializer)?;
        match cow {
            Cow::Borrowed(bytes) => Ok(Cow::Borrowed(Bytes::new(bytes))),
            Cow::Owned(bytes) => Ok(Cow::Owned(ByteBuf::from(bytes))),
        }
    }
}

#[cfg(any(feature = "std", feature = "alloc"))]
impl<'de> Deserialize<'de> for Box<[u8]> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        Deserialize::deserialize(deserializer).map(Vec::into_boxed_slice)
    }
}

#[cfg(any(feature = "std", feature = "alloc"))]
impl<'de> Deserialize<'de> for Box<Bytes> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let bytes: Box<[u8]> = Deserialize::deserialize(deserializer)?;
        Ok(bytes.into())
    }
}

impl<'de, T> Deserialize<'de> for Option<T>
where
    T: Deserialize<'de>,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct BytesVisitor<T> {
            out: PhantomData<T>,
        }

        impl<'de, T> Visitor<'de> for BytesVisitor<T>
        where
            T: Deserialize<'de>,
        {
            type Value = Option<T>;

            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
                f.write_str("optional byte array")
            }

            fn visit_unit<E: Error>(self) -> Result<Self::Value, E> {
                Ok(None)
            }

            fn visit_none<E: Error>(self) -> Result<Self::Value, E> {
                Ok(None)
            }

            fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
            where
                D: Deserializer<'de>,
            {
                T::deserialize(deserializer).map(Some)
            }
        }

        let visitor = BytesVisitor { out: PhantomData };
        deserializer.deserialize_option(visitor)
    }
}

Coverage Report

Created: 2025-07-12 06:37

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