torrust_serde_bencode/
value.rs

1//! Structures for representing bencoded values with Rust data types.
2
3use serde::de;
4use serde::ser::{self, SerializeMap, SerializeSeq};
5use serde_bytes::{ByteBuf, Bytes};
6use std::collections::HashMap;
7use std::fmt;
8
9/// All possible values which may be serialized in bencode.
10#[derive(PartialEq, Eq, Clone, Debug)]
11pub enum Value {
12    /// A generic list of bytes.
13    Bytes(Vec<u8>),
14
15    /// An integer.
16    Int(i64),
17
18    /// A list of other bencoded values.
19    List(Vec<Value>),
20
21    /// A map of (key, value) pairs.
22    Dict(HashMap<Vec<u8>, Value>),
23}
24
25impl ser::Serialize for Value {
26    #[inline]
27    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
28    where
29        S: ser::Serializer,
30    {
31        match *self {
32            Value::Bytes(ref v) => s.serialize_bytes(v),
33            Value::Int(v) => s.serialize_i64(v),
34            Value::List(ref v) => {
35                let mut seq = s.serialize_seq(Some(v.len()))?;
36                for e in v {
37                    seq.serialize_element(e)?;
38                }
39                seq.end()
40            }
41            Value::Dict(ref vs) => {
42                let mut map = s.serialize_map(Some(vs.len()))?;
43                for (k, v) in vs {
44                    map.serialize_entry(&Bytes::new(k), v)?;
45                }
46                map.end()
47            }
48        }
49    }
50}
51
52struct ValueVisitor;
53
54impl<'de> de::Visitor<'de> for ValueVisitor {
55    type Value = Value;
56
57    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
58        formatter.write_str("any valid BEncode value")
59    }
60
61    #[inline]
62    fn visit_i64<E>(self, value: i64) -> Result<Value, E> {
63        Ok(Value::Int(value))
64    }
65
66    #[inline]
67    fn visit_u64<E>(self, value: u64) -> Result<Value, E> {
68        Ok(Value::Int(value as i64))
69    }
70
71    #[inline]
72    fn visit_str<E>(self, value: &str) -> Result<Value, E>
73    where
74        E: de::Error,
75    {
76        Ok(Value::Bytes(value.into()))
77    }
78
79    #[inline]
80    fn visit_string<E>(self, value: String) -> Result<Value, E> {
81        Ok(Value::Bytes(value.into()))
82    }
83
84    #[inline]
85    fn visit_bytes<E>(self, value: &[u8]) -> Result<Value, E> {
86        Ok(Value::Bytes(value.into()))
87    }
88
89    #[inline]
90    fn visit_seq<V>(self, mut access: V) -> Result<Value, V::Error>
91    where
92        V: de::SeqAccess<'de>,
93    {
94        let mut seq = Vec::new();
95        while let Some(e) = access.next_element()? {
96            seq.push(e);
97        }
98        Ok(Value::List(seq))
99    }
100
101    #[inline]
102    fn visit_map<V>(self, mut access: V) -> Result<Value, V::Error>
103    where
104        V: de::MapAccess<'de>,
105    {
106        let mut map = HashMap::new();
107        while let Some((k, v)) = access.next_entry::<ByteBuf, _>()? {
108            map.insert(k.into_vec(), v);
109        }
110        Ok(Value::Dict(map))
111    }
112}
113
114impl<'de> de::Deserialize<'de> for Value {
115    #[inline]
116    fn deserialize<D>(deserializer: D) -> Result<Value, D::Error>
117    where
118        D: de::Deserializer<'de>,
119    {
120        deserializer.deserialize_any(ValueVisitor)
121    }
122}
123
124impl From<i64> for Value {
125    fn from(v: i64) -> Value {
126        Value::Int(v)
127    }
128}
129
130impl From<String> for Value {
131    fn from(s: String) -> Value {
132        Value::Bytes(s.into_bytes())
133    }
134}
135
136impl<'a> From<&'a str> for Value {
137    fn from(v: &str) -> Value {
138        Value::Bytes(v.as_bytes().to_vec())
139    }
140}
141
142impl From<Vec<u8>> for Value {
143    fn from(v: Vec<u8>) -> Value {
144        Value::Bytes(v)
145    }
146}
147
148impl From<Vec<Value>> for Value {
149    fn from(v: Vec<Value>) -> Value {
150        Value::List(v)
151    }
152}
153
154impl From<HashMap<Vec<u8>, Value>> for Value {
155    fn from(v: HashMap<Vec<u8>, Value>) -> Value {
156        Value::Dict(v)
157    }
158}