torrust_serde_bencode/
ser.rs

1//! Serialize a Rust data structure into bencode data.
2
3mod string;
4
5use crate::error::{Error, Result};
6use serde::ser;
7use std::mem;
8use std::str;
9
10/// A structure for serializing Rust values into bencode.
11#[derive(Default, Debug)]
12pub struct Serializer {
13    buf: Vec<u8>,
14}
15
16impl Serializer {
17    /// Create a new serializer.
18    pub fn new() -> Serializer {
19        Self::default()
20    }
21
22    /// Consume the serializer and return the contents as a byte vector.
23    pub fn into_vec(self) -> Vec<u8> {
24        self.buf
25    }
26
27    fn push<T: AsRef<[u8]>>(&mut self, token: T) {
28        self.buf.extend_from_slice(token.as_ref());
29    }
30}
31
32impl AsRef<[u8]> for Serializer {
33    fn as_ref(&self) -> &[u8] {
34        self.buf.as_ref()
35    }
36}
37
38impl<'a> ser::SerializeSeq for &'a mut Serializer {
39    type Ok = ();
40    type Error = Error;
41    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<()> {
42        value.serialize(&mut **self)
43    }
44    fn end(self) -> Result<()> {
45        self.push("e");
46        Ok(())
47    }
48}
49
50impl<'a> ser::SerializeTuple for &'a mut Serializer {
51    type Ok = ();
52    type Error = Error;
53    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<()> {
54        value.serialize(&mut **self)
55    }
56    fn end(self) -> Result<()> {
57        ser::SerializeSeq::end(self)
58    }
59}
60
61impl<'a> ser::SerializeTupleStruct for &'a mut Serializer {
62    type Ok = ();
63    type Error = Error;
64    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<()> {
65        value.serialize(&mut **self)
66    }
67    fn end(self) -> Result<()> {
68        ser::SerializeSeq::end(self)
69    }
70}
71
72impl<'a> ser::SerializeTupleVariant for &'a mut Serializer {
73    type Ok = ();
74    type Error = Error;
75    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<()> {
76        value.serialize(&mut **self)
77    }
78    fn end(self) -> Result<()> {
79        self.push("ee");
80        Ok(())
81    }
82}
83
84#[doc(hidden)]
85// TODO: This should be pub(crate).
86pub struct SerializeMap<'a> {
87    ser: &'a mut Serializer,
88    entries: Vec<(Vec<u8>, Vec<u8>)>,
89    cur_key: Option<Vec<u8>>,
90}
91
92impl<'a> SerializeMap<'a> {
93    pub fn new(ser: &'a mut Serializer, len: usize) -> SerializeMap {
94        SerializeMap {
95            ser,
96            entries: Vec::with_capacity(len),
97            cur_key: None,
98        }
99    }
100
101    fn end_map(&mut self) -> Result<()> {
102        if self.cur_key.is_some() {
103            return Err(Error::InvalidValue(
104                "`serialize_key` called without calling  `serialize_value`".to_string(),
105            ));
106        }
107        let mut entries = mem::take(&mut self.entries);
108        entries.sort_by(|&(ref a, _), &(ref b, _)| a.cmp(b));
109        self.ser.push("d");
110        for (k, v) in entries {
111            ser::Serializer::serialize_bytes(&mut *self.ser, k.as_ref())?;
112            self.ser.push(v);
113        }
114        self.ser.push("e");
115        Ok(())
116    }
117}
118
119impl<'a> ser::SerializeMap for SerializeMap<'a> {
120    type Ok = ();
121    type Error = Error;
122    fn serialize_key<T: ?Sized + ser::Serialize>(&mut self, key: &T) -> Result<()> {
123        if self.cur_key.is_some() {
124            return Err(Error::InvalidValue(
125                "`serialize_key` called multiple times without calling  `serialize_value`"
126                    .to_string(),
127            ));
128        }
129        self.cur_key = Some(key.serialize(&mut string::StringSerializer)?);
130        Ok(())
131    }
132    fn serialize_value<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<()> {
133        let key = self.cur_key.take().ok_or_else(|| {
134            Error::InvalidValue(
135                "`serialize_value` called without calling `serialize_key`".to_string(),
136            )
137        })?;
138        let mut ser = Serializer::new();
139        value.serialize(&mut ser)?;
140        let value = ser.into_vec();
141        if !value.is_empty() {
142            self.entries.push((key, value));
143        }
144        Ok(())
145    }
146    fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<()>
147    where
148        K: ?Sized + ser::Serialize,
149        V: ?Sized + ser::Serialize,
150    {
151        if self.cur_key.is_some() {
152            return Err(Error::InvalidValue(
153                "`serialize_key` called multiple times without calling  `serialize_value`"
154                    .to_string(),
155            ));
156        }
157        let key = key.serialize(&mut string::StringSerializer)?;
158        let mut ser = Serializer::new();
159        value.serialize(&mut ser)?;
160        let value = ser.into_vec();
161        if !value.is_empty() {
162            self.entries.push((key, value));
163        }
164        Ok(())
165    }
166    fn end(mut self) -> Result<()> {
167        self.end_map()
168    }
169}
170
171impl<'a> ser::SerializeStruct for SerializeMap<'a> {
172    type Ok = ();
173    type Error = Error;
174    fn serialize_field<T: ?Sized + ser::Serialize>(
175        &mut self,
176        key: &'static str,
177        value: &T,
178    ) -> Result<()> {
179        ser::SerializeMap::serialize_entry(self, key, value)
180    }
181    fn end(mut self) -> Result<()> {
182        self.end_map()
183    }
184}
185
186impl<'a> ser::SerializeStructVariant for SerializeMap<'a> {
187    type Ok = ();
188    type Error = Error;
189    fn serialize_field<T: ?Sized + ser::Serialize>(
190        &mut self,
191        key: &'static str,
192        value: &T,
193    ) -> Result<()> {
194        ser::SerializeMap::serialize_entry(self, key, value)
195    }
196    fn end(mut self) -> Result<()> {
197        self.end_map()?;
198        self.ser.push("e");
199        Ok(())
200    }
201}
202
203impl<'a> ser::Serializer for &'a mut Serializer {
204    type Ok = ();
205    type Error = Error;
206    type SerializeSeq = Self;
207    type SerializeTuple = Self;
208    type SerializeTupleStruct = Self;
209    type SerializeTupleVariant = Self;
210    type SerializeMap = SerializeMap<'a>;
211    type SerializeStruct = SerializeMap<'a>;
212    type SerializeStructVariant = SerializeMap<'a>;
213
214    fn serialize_bool(self, value: bool) -> Result<()> {
215        self.serialize_i64(value as i64)
216    }
217    fn serialize_i8(self, value: i8) -> Result<()> {
218        self.serialize_i64(value as i64)
219    }
220    fn serialize_i16(self, value: i16) -> Result<()> {
221        self.serialize_i64(value as i64)
222    }
223    fn serialize_i32(self, value: i32) -> Result<()> {
224        self.serialize_i64(value as i64)
225    }
226    fn serialize_i64(self, value: i64) -> Result<()> {
227        self.push("i");
228        self.push(value.to_string());
229        self.push("e");
230        Ok(())
231    }
232    fn serialize_u8(self, value: u8) -> Result<()> {
233        self.serialize_u64(value as u64)
234    }
235    fn serialize_u16(self, value: u16) -> Result<()> {
236        self.serialize_u64(value as u64)
237    }
238    fn serialize_u32(self, value: u32) -> Result<()> {
239        self.serialize_u64(value as u64)
240    }
241    fn serialize_u64(self, value: u64) -> Result<()> {
242        self.push("i");
243        self.push(value.to_string());
244        self.push("e");
245        Ok(())
246    }
247    fn serialize_f32(self, _value: f32) -> Result<()> {
248        Err(Error::InvalidValue("Cannot serialize f32".to_string()))
249    }
250    fn serialize_f64(self, _value: f64) -> Result<()> {
251        Err(Error::InvalidValue("Cannot serialize f64".to_string()))
252    }
253    fn serialize_char(self, value: char) -> Result<()> {
254        let mut buffer = [0; 4];
255        self.serialize_bytes(value.encode_utf8(&mut buffer).as_bytes())
256    }
257
258    fn serialize_str(self, value: &str) -> Result<()> {
259        self.serialize_bytes(value.as_bytes())
260    }
261    fn serialize_bytes(self, value: &[u8]) -> Result<()> {
262        self.push(value.len().to_string());
263        self.push(":");
264        self.push(value);
265        Ok(())
266    }
267    fn serialize_unit(self) -> Result<()> {
268        Ok(())
269    }
270    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
271        self.serialize_unit()
272    }
273    fn serialize_unit_variant(
274        self,
275        _name: &'static str,
276        _variant_index: u32,
277        variant: &'static str,
278    ) -> Result<()> {
279        self.serialize_str(variant)
280    }
281    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
282        self,
283        _name: &'static str,
284        value: &T,
285    ) -> Result<()> {
286        value.serialize(self)
287    }
288    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
289        self,
290        _name: &'static str,
291        _variant_index: u32,
292        variant: &'static str,
293        value: &T,
294    ) -> Result<()> {
295        self.push("d");
296        self.serialize_bytes(variant.as_bytes())?;
297        value.serialize(&mut *self)?;
298        self.push("e");
299        Ok(())
300    }
301    fn serialize_none(self) -> Result<()> {
302        Ok(())
303    }
304    fn serialize_some<T: ?Sized + ser::Serialize>(self, value: &T) -> Result<()> {
305        value.serialize(self)
306    }
307    fn serialize_seq(self, _len: Option<usize>) -> Result<Self> {
308        self.push("l");
309        Ok(self)
310    }
311    fn serialize_tuple(self, size: usize) -> Result<Self> {
312        self.serialize_seq(Some(size))
313    }
314    fn serialize_tuple_struct(self, _name: &'static str, len: usize) -> Result<Self> {
315        self.serialize_seq(Some(len))
316    }
317    fn serialize_tuple_variant(
318        self,
319        _name: &'static str,
320        _variant_index: u32,
321        variant: &'static str,
322        _len: usize,
323    ) -> Result<Self::SerializeTupleVariant> {
324        self.push("d");
325        self.serialize_bytes(variant.as_bytes())?;
326        self.push("l");
327        Ok(self)
328    }
329    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
330        Ok(SerializeMap::new(self, len.unwrap_or(0)))
331    }
332    fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
333        self.serialize_map(Some(len))
334    }
335    fn serialize_struct_variant(
336        self,
337        _name: &'static str,
338        _variant_index: u32,
339        variant: &'static str,
340        len: usize,
341    ) -> Result<Self::SerializeStructVariant> {
342        self.push("d");
343        self.serialize_bytes(variant.as_bytes())?;
344        Ok(SerializeMap::new(self, len))
345    }
346}
347
348/// Serialize the given data into a bencode byte vector.
349///
350/// # Examples
351/// ```
352/// # fn main() -> Result<(), serde_bencode::Error> {
353/// use serde_derive::{Serialize, Deserialize};
354///
355/// #[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
356/// struct Address {
357///     street: String,
358///     city: String,
359/// }
360///
361/// let address = Address {
362///     street: "1313 Webfoot Walk".to_string(),
363///     city: "Duckburg, Calisota".to_string(),
364/// };
365///
366/// let bytes = serde_bencode::to_bytes(&address)?;
367/// assert_eq!(
368///     String::from_utf8(bytes).unwrap(),
369///     "d4:city18:Duckburg, Calisota6:street17:1313 Webfoot Walke",
370/// );
371/// # Ok(())
372/// # }
373/// ```
374///
375/// # Errors
376///
377/// Serialization can fail if `T`'s implementation of `Serialize` decides to fail or `T` contains
378/// floating point values, which bencode cannot serialize.
379pub fn to_bytes<T: ser::Serialize>(b: &T) -> Result<Vec<u8>> {
380    let mut ser = Serializer::new();
381    b.serialize(&mut ser)?;
382    Ok(ser.into_vec())
383}
384
385/// Serialize the given data into a String of bencode.
386///
387/// # Examples
388/// ```
389/// # fn main() -> Result<(), serde_bencode::Error> {
390/// use serde_derive::{Serialize, Deserialize};
391///
392/// #[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
393/// struct Address {
394///     street: String,
395///     city: String,
396/// }
397///
398/// let address = Address {
399///     street: "1313 Webfoot Walk".to_string(),
400///     city: "Duckburg, Calisota".to_string(),
401/// };
402///
403/// assert_eq!(
404///     serde_bencode::to_string(&address)?,
405///     "d4:city18:Duckburg, Calisota6:street17:1313 Webfoot Walke".to_string(),
406/// );
407/// # Ok(())
408/// # }
409/// ```
410///
411/// # Errors
412///
413/// Serialization can fail if `T`'s implementation of `Serialize` decides to fail or `T` contains
414/// floating point values, which bencode cannot serialize.
415pub fn to_string<T: ser::Serialize>(b: &T) -> Result<String> {
416    let mut ser = Serializer::new();
417    b.serialize(&mut ser)?;
418    str::from_utf8(ser.as_ref())
419        .map(|s| s.to_string())
420        .map_err(|_| Error::InvalidValue("Not an UTF-8".to_string()))
421}
torrust_serde_bencode/ser.rs

torrust_serde_bencode/
ser.rs
