1use crate::bencode::{Error, Result};
2use serde::de::{Error as _, IntoDeserializer, Unexpected};
3use serde::ser::{SerializeMap, SerializeSeq};
4use serde::{de, forward_to_deserialize_any, Deserializer, Serialize, Serializer};
5use serde_bytes::{ByteBuf, Bytes};
6use std::collections::HashMap;
7use std::{fmt, result};
8
9#[derive(PartialEq, Eq, Clone, Debug)]
11pub enum Value {
12 Bytes(Vec<u8>),
14 Int(i64),
16 List(Vec<Value>),
18 Dict(HashMap<Vec<u8>, Value>),
20}
21
22impl Serialize for Value {
23 #[inline]
24 fn serialize<S>(&self, s: S) -> result::Result<S::Ok, S::Error>
25 where
26 S: Serializer,
27 {
28 match *self {
29 Value::Bytes(ref v) => s.serialize_bytes(v),
30 Value::Int(v) => s.serialize_i64(v),
31 Value::List(ref v) => {
32 let mut seq = s.serialize_seq(Some(v.len()))?;
33 for e in v {
34 seq.serialize_element(e)?;
35 }
36 seq.end()
37 }
38 Value::Dict(ref vs) => {
39 let mut map = s.serialize_map(Some(vs.len()))?;
40 for (k, v) in vs {
41 map.serialize_entry(&Bytes::new(k), v)?;
42 }
43 map.end()
44 }
45 }
46 }
47}
48
49impl<'de> Deserializer<'de> for &'de Value {
50 type Error = Error;
51
52 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
53 where
54 V: de::Visitor<'de>,
55 {
56 match self {
57 Value::Int(i) => visitor.visit_i64(*i),
58 Value::Bytes(v) => visitor.visit_bytes(v.as_slice()),
59 Value::List(v) => {
60 let mut seq = de::value::SeqDeserializer::new(v.iter());
61 visitor.visit_seq(&mut seq)
62 }
63 Value::Dict(v) => {
64 let mut map =
65 de::value::MapDeserializer::new(v.iter().map(|(k, v)| (k.as_slice(), v)));
66 visitor.visit_map(&mut map)
67 }
68 }
69 }
70
71 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
73 where
74 V: de::Visitor<'de>,
75 {
76 match self {
77 Value::Bytes(v) => {
78 let s = String::from_utf8(v.clone()).map_err(|e| {
79 Error::invalid_value(Unexpected::Bytes(&e.into_bytes()), &"valid utf-8")
80 })?;
81 visitor.visit_string(s)
82 }
83 _ => self.deserialize_any(visitor),
84 }
85 }
86
87 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
88 where
89 V: de::Visitor<'de>,
90 {
91 self.deserialize_str(visitor)
92 }
93
94 fn deserialize_enum<V>(
95 self,
96 _name: &'static str,
97 _variants: &'static [&'static str],
98 visitor: V,
99 ) -> Result<V::Value>
100 where
101 V: de::Visitor<'de>,
102 {
103 match self {
104 Value::Bytes(v) => {
105 let s = String::from_utf8(v.clone()).map_err(|e| {
106 Error::invalid_value(Unexpected::Bytes(&e.into_bytes()), &"valid utf-8")
107 })?;
108 visitor.visit_enum(s.into_deserializer())
109 }
110 Value::Dict(ref v) => {
111 let (key, value) = v
112 .iter()
113 .next()
114 .ok_or(Error::invalid_length(v.len(), &"map with 1 entry"))?;
115 let s = str::from_utf8(key)
116 .map_err(|_| Error::invalid_value(Unexpected::Bytes(key), &"valid utf-8"))?;
117 visitor.visit_enum(EnumDeserializer {
118 variant: s,
119 value: &value,
120 })
121 }
122 _ => Err(Error::invalid_type(Unexpected::Unit, &"string or map")),
123 }
124 }
125
126 fn deserialize_option<V>(self, visitor: V) -> result::Result<V::Value, Self::Error>
127 where
128 V: de::Visitor<'de>,
129 {
130 visitor.visit_some(self)
131 }
132
133 fn deserialize_bool<V>(self, visitor: V) -> result::Result<V::Value, Self::Error>
134 where
135 V: de::Visitor<'de>,
136 {
137 let val = match self {
138 Value::Int(i) => Ok(*i == 1),
139 Value::Bytes(e) => Err(Error::invalid_type(Unexpected::Bytes(e), &"bool")),
140 Value::List(_) => Err(Error::invalid_type(Unexpected::Seq, &"bool")),
141 Value::Dict(_) => Err(Error::invalid_type(Unexpected::Map, &"bool")),
142 }?;
143 visitor.visit_bool(val)
144 }
145
146 forward_to_deserialize_any! {
147 char i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 unit unit_struct
148 seq map tuple_struct struct identifier tuple ignored_any bytes
149 byte_buf newtype_struct
150 }
151}
152
153impl<'de> IntoDeserializer<'de, Error> for &'de Value {
154 type Deserializer = Self;
155 fn into_deserializer(self) -> Self::Deserializer {
156 self
157 }
158}
159
160#[derive(Debug)]
161struct ValueVisitor;
162impl<'de> de::Visitor<'de> for ValueVisitor {
163 type Value = Value;
164
165 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
166 formatter.write_str("any valid bencode value")
167 }
168
169 #[inline]
170 fn visit_i64<E>(self, value: i64) -> result::Result<Value, E> {
171 Ok(Value::Int(value))
172 }
173
174 #[inline]
175 fn visit_u64<E>(self, value: u64) -> result::Result<Value, E> {
176 Ok(Value::Int(value as i64))
177 }
178
179 #[inline]
180 fn visit_str<E>(self, value: &str) -> result::Result<Value, E>
181 where
182 E: de::Error,
183 {
184 Ok(Value::Bytes(value.into()))
185 }
186
187 #[inline]
188 fn visit_string<E>(self, value: String) -> result::Result<Value, E> {
189 Ok(Value::Bytes(value.into()))
190 }
191
192 #[inline]
193 fn visit_bytes<E>(self, value: &[u8]) -> result::Result<Value, E> {
194 Ok(Value::Bytes(value.into()))
195 }
196
197 #[inline]
198 fn visit_seq<V>(self, mut access: V) -> result::Result<Value, V::Error>
199 where
200 V: de::SeqAccess<'de>,
201 {
202 let mut seq = Vec::new();
203 while let Some(e) = access.next_element()? {
204 seq.push(e);
205 }
206 Ok(Value::List(seq))
207 }
208
209 #[inline]
210 fn visit_map<V>(self, mut access: V) -> result::Result<Value, V::Error>
211 where
212 V: de::MapAccess<'de>,
213 {
214 let mut map = HashMap::new();
215 while let Some((k, v)) = access.next_entry::<ByteBuf, _>()? {
216 map.insert(k.into_vec(), v);
217 }
218 Ok(Value::Dict(map))
219 }
220}
221
222impl<'de> de::Deserialize<'de> for Value {
223 #[inline]
224 fn deserialize<D>(deserializer: D) -> result::Result<Value, D::Error>
225 where
226 D: Deserializer<'de>,
227 {
228 deserializer.deserialize_any(ValueVisitor)
229 }
230}
231
232impl From<i64> for Value {
233 fn from(v: i64) -> Value {
234 Value::Int(v)
235 }
236}
237
238impl From<String> for Value {
239 fn from(s: String) -> Value {
240 Value::Bytes(s.into_bytes())
241 }
242}
243
244impl<'a> From<&'a str> for Value {
245 fn from(v: &str) -> Value {
246 Value::Bytes(v.as_bytes().to_vec())
247 }
248}
249
250impl From<Vec<u8>> for Value {
251 fn from(v: Vec<u8>) -> Value {
252 Value::Bytes(v)
253 }
254}
255
256impl From<Vec<Value>> for Value {
257 fn from(v: Vec<Value>) -> Value {
258 Value::List(v)
259 }
260}
261
262impl From<HashMap<Vec<u8>, Value>> for Value {
263 fn from(v: HashMap<Vec<u8>, Value>) -> Value {
264 Value::Dict(v)
265 }
266}
267
268#[derive(Debug)]
269struct EnumDeserializer<'de> {
270 variant: &'de str,
271 value: &'de Value,
272}
273
274impl<'de> de::EnumAccess<'de> for EnumDeserializer<'de> {
275 type Error = Error;
276 type Variant = Self;
277
278 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
279 where
280 V: de::DeserializeSeed<'de>,
281 {
282 let variant_de: de::value::StrDeserializer<Error> = self.variant.into_deserializer();
283 let variant = seed.deserialize(variant_de)?;
284 Ok((variant, self))
285 }
286}
287
288impl<'de> de::VariantAccess<'de> for EnumDeserializer<'de> {
289 type Error = Error;
290
291 fn unit_variant(self) -> Result<()> {
292 de::Deserialize::deserialize(self.value)
293 }
294
295 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
296 where
297 T: de::DeserializeSeed<'de>,
298 {
299 seed.deserialize(self.value)
300 }
301
302 fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
303 where
304 V: de::Visitor<'de>,
305 {
306 Deserializer::deserialize_seq(self.value, visitor)
307 }
308
309 fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
310 where
311 V: de::Visitor<'de>,
312 {
313 Deserializer::deserialize_map(self.value, visitor)
314 }
315}
316
317pub fn from_value<'de, T>(value: &'de Value) -> Result<T>
319where
320 T: de::Deserialize<'de>,
321{
322 T::deserialize(value)
323}
324
325#[cfg(test)]
326mod tests {
327 use super::*;
328 use crate::bencode;
329 use serde::Deserialize;
330
331 #[derive(Debug, Serialize, Deserialize, PartialEq)]
332 struct TestStruct {
333 pub id: u64,
334 pub enabled: bool,
335 #[serde(default)]
336 pub version: Option<String>,
337 }
338
339 mod from_value {
340 use super::*;
341
342 #[test]
343 fn test_deserialize() {
344 let expected_result = TestStruct {
345 id: 1,
346 enabled: true,
347 version: Some("my-version".to_string()),
348 };
349
350 let bytes = bencode::to_bytes(&expected_result).unwrap();
351 let value: Value = bencode::from_bytes(bytes.as_slice()).unwrap();
352
353 let result: TestStruct = from_value(&value).expect("expected value to be deserialized");
354 assert_eq!(
355 expected_result, result,
356 "expected deserialized value to match expected"
357 )
358 }
359
360 #[test]
361 fn test_deserialize_none_field() {
362 let expected_result = TestStruct {
363 id: 67,
364 enabled: false,
365 version: None,
366 };
367
368 let message = bencode::to_string(&expected_result).unwrap();
369 let value: Value = bencode::from_str(message.as_str()).unwrap();
370
371 let result: TestStruct = from_value(&value).expect("expected value to be deserialized");
372 assert_eq!(
373 expected_result, result,
374 "expected deserialized value to match expected"
375 )
376 }
377 }
378}