fx_torrent/bencode/
serialize.rs1use 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 pub fn new() -> Serializer {
13 Self::default()
14 }
15
16 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
223pub 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
230pub 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}