torrust_serde_bencode/
value.rs1use serde::de;
4use serde::ser::{self, SerializeMap, SerializeSeq};
5use serde_bytes::{ByteBuf, Bytes};
6use std::collections::HashMap;
7use std::fmt;
8
9#[derive(PartialEq, Eq, Clone, Debug)]
11pub enum Value {
12 Bytes(Vec<u8>),
14
15 Int(i64),
17
18 List(Vec<Value>),
20
21 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}