Skip to main content

fx_torrent/bencode/
serialize.rs

1use crate::bencode::ser::map::SerializeMap;
2use crate::bencode::{Error, Result};
3use serde::ser;
4
5#[derive(Default, Debug)]
6pub struct Serializer {
7    buf: Vec<u8>,
8}
9
10impl Serializer {
11    /// Create a new serializer.
12    pub fn new() -> Serializer {
13        Self::default()
14    }
15
16    /// Consume the serializer and return the contents as a byte vector.
17    pub fn into_vec(self) -> Vec<u8> {
18        self.buf
19    }
20
21    pub(crate) fn push<T: AsRef<[u8]>>(&mut self, token: T) {
22        self.buf.extend_from_slice(token.as_ref());
23    }
24}
25
26impl AsRef<[u8]> for Serializer {
27    fn as_ref(&self) -> &[u8] {
28        self.buf.as_ref()
29    }
30}
31
32impl<'a> ser::SerializeSeq for &'a mut Serializer {
33    type Ok = ();
34    type Error = Error;
35    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<()> {
36        value.serialize(&mut **self)
37    }
38    fn end(self) -> Result<()> {
39        self.push("e");
40        Ok(())
41    }
42}
43
44impl<'a> ser::SerializeTuple for &'a mut Serializer {
45    type Ok = ();
46    type Error = Error;
47    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<()> {
48        value.serialize(&mut **self)
49    }
50    fn end(self) -> Result<()> {
51        ser::SerializeSeq::end(self)
52    }
53}
54
55impl<'a> ser::SerializeTupleStruct for &'a mut Serializer {
56    type Ok = ();
57    type Error = Error;
58    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<()> {
59        value.serialize(&mut **self)
60    }
61    fn end(self) -> Result<()> {
62        ser::SerializeSeq::end(self)
63    }
64}
65
66impl<'a> ser::SerializeTupleVariant for &'a mut Serializer {
67    type Ok = ();
68    type Error = Error;
69    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<()> {
70        value.serialize(&mut **self)
71    }
72    fn end(self) -> Result<()> {
73        self.push("ee");
74        Ok(())
75    }
76}
77
78impl<'a> ser::Serializer for &'a mut Serializer {
79    type Ok = ();
80    type Error = Error;
81    type SerializeSeq = Self;
82    type SerializeTuple = Self;
83    type SerializeTupleStruct = Self;
84    type SerializeTupleVariant = Self;
85    type SerializeMap = SerializeMap<'a>;
86    type SerializeStruct = SerializeMap<'a>;
87    type SerializeStructVariant = SerializeMap<'a>;
88
89    fn serialize_bool(self, value: bool) -> Result<()> {
90        self.serialize_i64(i64::from(value))
91    }
92    fn serialize_i8(self, value: i8) -> Result<()> {
93        self.serialize_i64(i64::from(value))
94    }
95    fn serialize_i16(self, value: i16) -> Result<()> {
96        self.serialize_i64(i64::from(value))
97    }
98    fn serialize_i32(self, value: i32) -> Result<()> {
99        self.serialize_i64(i64::from(value))
100    }
101    fn serialize_i64(self, value: i64) -> Result<()> {
102        self.push("i");
103        self.push(value.to_string());
104        self.push("e");
105        Ok(())
106    }
107    fn serialize_u8(self, value: u8) -> Result<()> {
108        self.serialize_u64(u64::from(value))
109    }
110    fn serialize_u16(self, value: u16) -> Result<()> {
111        self.serialize_u64(u64::from(value))
112    }
113    fn serialize_u32(self, value: u32) -> Result<()> {
114        self.serialize_u64(u64::from(value))
115    }
116    fn serialize_u64(self, value: u64) -> Result<()> {
117        self.push("i");
118        self.push(value.to_string());
119        self.push("e");
120        Ok(())
121    }
122    fn serialize_f32(self, _value: f32) -> Result<()> {
123        Err(Error::InvalidValue("Cannot serialize f32".to_string()))
124    }
125    fn serialize_f64(self, _value: f64) -> Result<()> {
126        Err(Error::InvalidValue("Cannot serialize f64".to_string()))
127    }
128    fn serialize_char(self, value: char) -> Result<()> {
129        let mut buffer = [0; 4];
130        self.serialize_bytes(value.encode_utf8(&mut buffer).as_bytes())
131    }
132
133    fn serialize_str(self, value: &str) -> Result<()> {
134        self.serialize_bytes(value.as_bytes())
135    }
136    fn serialize_bytes(self, value: &[u8]) -> Result<()> {
137        self.push(value.len().to_string());
138        self.push(":");
139        self.push(value);
140        Ok(())
141    }
142    fn serialize_none(self) -> Result<()> {
143        Ok(())
144    }
145    fn serialize_some<T: ?Sized + ser::Serialize>(self, value: &T) -> Result<()> {
146        value.serialize(self)
147    }
148    fn serialize_unit(self) -> Result<()> {
149        Ok(())
150    }
151    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
152        self.serialize_unit()
153    }
154    fn serialize_unit_variant(
155        self,
156        _name: &'static str,
157        _variant_index: u32,
158        variant: &'static str,
159    ) -> Result<()> {
160        self.serialize_str(variant)
161    }
162    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
163        self,
164        _name: &'static str,
165        value: &T,
166    ) -> Result<()> {
167        value.serialize(self)
168    }
169    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
170        self,
171        _name: &'static str,
172        _variant_index: u32,
173        variant: &'static str,
174        value: &T,
175    ) -> Result<()> {
176        self.push("d");
177        self.serialize_bytes(variant.as_bytes())?;
178        value.serialize(&mut *self)?;
179        self.push("e");
180        Ok(())
181    }
182    fn serialize_seq(self, _len: Option<usize>) -> Result<Self> {
183        self.push("l");
184        Ok(self)
185    }
186    fn serialize_tuple(self, size: usize) -> Result<Self> {
187        self.serialize_seq(Some(size))
188    }
189    fn serialize_tuple_struct(self, _name: &'static str, len: usize) -> Result<Self> {
190        self.serialize_seq(Some(len))
191    }
192    fn serialize_tuple_variant(
193        self,
194        _name: &'static str,
195        _variant_index: u32,
196        variant: &'static str,
197        _len: usize,
198    ) -> Result<Self::SerializeTupleVariant> {
199        self.push("d");
200        self.serialize_bytes(variant.as_bytes())?;
201        self.push("l");
202        Ok(self)
203    }
204    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
205        Ok(SerializeMap::new(self, len.unwrap_or(0)))
206    }
207    fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
208        self.serialize_map(Some(len))
209    }
210    fn serialize_struct_variant(
211        self,
212        _name: &'static str,
213        _variant_index: u32,
214        variant: &'static str,
215        len: usize,
216    ) -> Result<Self::SerializeStructVariant> {
217        self.push("d");
218        self.serialize_bytes(variant.as_bytes())?;
219        Ok(SerializeMap::new(self, len))
220    }
221}
222
223/// Serialize the given data into a bencode byte vector.
224pub fn to_bytes<T: ser::Serialize>(b: &T) -> Result<Vec<u8>> {
225    let mut ser = Serializer::new();
226    b.serialize(&mut ser)?;
227    Ok(ser.into_vec())
228}
229
230/// Serialize the given data into a String of bencode.
231pub fn to_string<T: ser::Serialize>(b: &T) -> Result<String> {
232    let mut ser = Serializer::new();
233    b.serialize(&mut ser)?;
234    str::from_utf8(ser.as_ref())
235        .map(ToString::to_string)
236        .map_err(|_| Error::InvalidValue("Not an UTF-8".to_string()))
237}
238
239#[cfg(test)]
240mod tests {
241    use super::*;
242    use crate::bencode::from_str;
243    use serde::{Deserialize, Serialize};
244
245    #[derive(Debug, Serialize, Deserialize, PartialEq)]
246    struct TestStruct {
247        inner: InnerStruct,
248        active: bool,
249        messages: Vec<String>,
250    }
251
252    #[derive(Debug, Serialize, Deserialize, PartialEq)]
253    struct InnerStruct {
254        message: String,
255    }
256
257    #[test]
258    fn test_serialize_bool() {
259        assert_eq!(to_string(&true).unwrap(), "i1e");
260        assert_eq!(to_string(&false).unwrap(), "i0e");
261    }
262
263    #[test]
264    fn test_serialize_struct() {
265        let expected_result = TestStruct {
266            inner: InnerStruct {
267                message: "FooBar".to_string(),
268            },
269            active: true,
270            messages: vec!["lorem".to_string(), "ipsum".to_string()],
271        };
272
273        let payload = to_string(&expected_result).unwrap();
274        let result = from_str(payload.as_str()).unwrap();
275
276        assert_eq!(expected_result, result);
277    }
278}