1 use crate::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)]
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>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] {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,37     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
38     where
39         D: Deserializer<'de>,
40     {
41         // Via the serde::Deserialize impl for &[u8].
42         serde::Deserialize::deserialize(deserializer)
43     }
44 }
45 
46 #[cfg(any(feature = "std", feature = "alloc"))]
47 impl<'de> Deserialize<'de> for Vec<u8> {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,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 
56 impl<'de: 'a, 'a> Deserialize<'de> for &'a Bytes {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,57     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
58     where
59         D: Deserializer<'de>,
60     {
61         Deserialize::deserialize(deserializer).map(Bytes::new)
62     }
63 }
64 
65 #[cfg(any(feature = "std", feature = "alloc"))]
66 impl<'de> Deserialize<'de> for ByteBuf {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,67     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
68     where
69         D: Deserializer<'de>,
70     {
71         // Via the serde::Deserialize impl for ByteBuf.
72         serde::Deserialize::deserialize(deserializer)
73     }
74 }
75 
76 #[cfg(any(feature = "std", feature = "alloc"))]
77 impl<'de: 'a, 'a> Deserialize<'de> for Cow<'a, [u8]> {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,78     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
79     where
80         D: Deserializer<'de>,
81     {
82         struct CowVisitor;
83 
84         impl<'de> Visitor<'de> for CowVisitor {
85             type Value = Cow<'de, [u8]>;
86 
87             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
88                 formatter.write_str("a byte array")
89             }
90 
91             fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
92             where
93                 E: Error,
94             {
95                 Ok(Cow::Borrowed(v))
96             }
97 
98             fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
99             where
100                 E: Error,
101             {
102                 Ok(Cow::Borrowed(v.as_bytes()))
103             }
104 
105             fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
106             where
107                 E: Error,
108             {
109                 Ok(Cow::Owned(v.to_vec()))
110             }
111 
112             fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
113             where
114                 E: Error,
115             {
116                 Ok(Cow::Owned(v.as_bytes().to_vec()))
117             }
118 
119             fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
120             where
121                 E: Error,
122             {
123                 Ok(Cow::Owned(v))
124             }
125 
126             fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
127             where
128                 E: Error,
129             {
130                 Ok(Cow::Owned(v.into_bytes()))
131             }
132 
133             fn visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
134             where
135                 V: SeqAccess<'de>,
136             {
137                 let len = cmp::min(visitor.size_hint().unwrap_or(0), 4096);
138                 let mut bytes = Vec::with_capacity(len);
139 
140                 while let Some(b) = visitor.next_element()? {
141                     bytes.push(b);
142                 }
143 
144                 Ok(Cow::Owned(bytes))
145             }
146         }
147 
148         deserializer.deserialize_bytes(CowVisitor)
149     }
150 }
151 
152 #[cfg(any(feature = "std", feature = "alloc"))]
153 impl<'de: 'a, 'a> Deserialize<'de> for Cow<'a, Bytes> {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,154     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
155     where
156         D: Deserializer<'de>,
157     {
158         let cow: Cow<[u8]> = Deserialize::deserialize(deserializer)?;
159         match cow {
160             Cow::Borrowed(bytes) => Ok(Cow::Borrowed(Bytes::new(bytes))),
161             Cow::Owned(bytes) => Ok(Cow::Owned(ByteBuf::from(bytes))),
162         }
163     }
164 }
165 
166 #[cfg(any(feature = "std", feature = "alloc"))]
167 impl<'de> Deserialize<'de> for Box<[u8]> {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,168     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
169     where
170         D: Deserializer<'de>,
171     {
172         Deserialize::deserialize(deserializer).map(Vec::into_boxed_slice)
173     }
174 }
175 
176 #[cfg(any(feature = "std", feature = "alloc"))]
177 impl<'de> Deserialize<'de> for Box<Bytes> {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,178     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
179     where
180         D: Deserializer<'de>,
181     {
182         let bytes: Box<[u8]> = Deserialize::deserialize(deserializer)?;
183         Ok(bytes.into())
184     }
185 }
186 
187 impl<'de, T> Deserialize<'de> for Option<T>
188 where
189     T: Deserialize<'de>,
190 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,191     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
192     where
193         D: Deserializer<'de>,
194     {
195         struct BytesVisitor<T> {
196             out: PhantomData<T>,
197         }
198 
199         impl<'de, T> Visitor<'de> for BytesVisitor<T>
200         where
201             T: Deserialize<'de>,
202         {
203             type Value = Option<T>;
204 
205             fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
206                 f.write_str("optional byte array")
207             }
208 
209             fn visit_unit<E: Error>(self) -> Result<Self::Value, E> {
210                 Ok(None)
211             }
212 
213             fn visit_none<E: Error>(self) -> Result<Self::Value, E> {
214                 Ok(None)
215             }
216 
217             fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
218             where
219                 D: Deserializer<'de>,
220             {
221                 T::deserialize(deserializer).map(Some)
222             }
223         }
224 
225         let visitor = BytesVisitor { out: PhantomData };
226         deserializer.deserialize_option(visitor)
227     }
228 }
229