1use crate::encoding_utils::write_var_int;
2use crate::error::{BitcoinCodeError, Error, ErrorKind, Result};
3use byteorder::{LittleEndian, WriteBytesExt};
4use std::io;
5
6struct Serializer<W> {
7 writer: W,
8}
9
10struct Compound<'a, W: 'a> {
11 ser: &'a mut Serializer<W>,
12}
13
14impl serde::ser::Error for Error {
15 fn custom<T: std::fmt::Display>(msg: T) -> Self {
16 ErrorKind::Msg(msg.to_string()).into()
17 }
18}
19
20impl<'a, W: io::Write> serde::ser::Serializer for &'a mut Serializer<W> {
21 type Ok = ();
22 type Error = Error;
23 type SerializeSeq = Compound<'a, W>;
24 type SerializeTuple = Compound<'a, W>;
25 type SerializeTupleStruct = Compound<'a, W>;
26 type SerializeTupleVariant = Compound<'a, W>;
27 type SerializeMap = Compound<'a, W>;
28 type SerializeStruct = Compound<'a, W>;
29 type SerializeStructVariant = Compound<'a, W>;
30
31 fn serialize_unit(self) -> Result<()> {
32 Ok(())
33 }
34
35 fn serialize_unit_struct(self, _: &'static str) -> Result<()> {
36 Ok(())
37 }
38
39 fn serialize_bool(self, v: bool) -> Result<()> {
40 self.writer
41 .write_u8(if v { 1 } else { 0 })
42 .map_err(Into::into)
43 }
44
45 fn serialize_u8(self, v: u8) -> Result<()> {
46 self.writer.write_u8(v).map_err(Into::into)
47 }
48
49 fn serialize_u16(self, v: u16) -> Result<()> {
50 self.writer.write_u16::<LittleEndian>(v).map_err(Into::into)
51 }
52
53 fn serialize_u32(self, v: u32) -> Result<()> {
54 self.writer.write_u32::<LittleEndian>(v).map_err(Into::into)
55 }
56
57 fn serialize_u64(self, v: u64) -> Result<()> {
58 self.writer.write_u64::<LittleEndian>(v).map_err(Into::into)
59 }
60
61 fn serialize_i8(self, v: i8) -> Result<()> {
62 self.writer.write_i8(v).map_err(Into::into)
63 }
64
65 fn serialize_i16(self, v: i16) -> Result<()> {
66 self.writer.write_i16::<LittleEndian>(v).map_err(Into::into)
67 }
68
69 fn serialize_i32(self, v: i32) -> Result<()> {
70 self.writer.write_i32::<LittleEndian>(v).map_err(Into::into)
71 }
72
73 fn serialize_i64(self, v: i64) -> Result<()> {
74 self.writer.write_i64::<LittleEndian>(v).map_err(Into::into)
75 }
76
77 fn serialize_u128(self, _v: u128) -> Result<()> {
78 BitcoinCodeError::DataTypeNotSupported("u128").into_err()
79 }
80
81 fn serialize_i128(self, _v: i128) -> Result<()> {
82 BitcoinCodeError::DataTypeNotSupported("i128").into_err()
83 }
84
85 fn serialize_f32(self, _v: f32) -> Result<()> {
86 BitcoinCodeError::DataTypeNotSupported("f32").into_err()
87 }
88
89 fn serialize_f64(self, _v: f64) -> Result<()> {
90 BitcoinCodeError::DataTypeNotSupported("f64").into_err()
91 }
92
93 fn serialize_str(self, v: &str) -> Result<()> {
94 write_var_int(&mut self.writer, v.len() as u64)?;
95 self.writer.write_all(v.as_bytes())?;
96 Ok(())
97 }
98
99 fn serialize_char(self, _c: char) -> Result<()> {
100 BitcoinCodeError::DataTypeNotSupported("char").into_err()
101 }
102
103 fn serialize_bytes(self, v: &[u8]) -> Result<()> {
104 write_var_int(&mut self.writer, v.len() as u64)?;
105 self.writer.write_all(v)?;
106 Ok(())
107 }
108
109 fn serialize_none(self) -> Result<()> {
110 BitcoinCodeError::MethodNotSupported("serialize_none").into_err()
111 }
112
113 fn serialize_some<T: ?Sized>(self, _v: &T) -> Result<()>
114 where
115 T: serde::Serialize,
116 {
117 BitcoinCodeError::MethodNotSupported("serialize_some").into_err()
118 }
119
120 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
121 let len = match len {
122 Some(len) => len,
123 None => return BitcoinCodeError::SequenceMustHaveLength.into_err(),
124 };
125 write_var_int(&mut self.writer, len as u64)?;
126 Ok(Compound { ser: self })
127 }
128
129 fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
130 Ok(Compound { ser: self })
131 }
132
133 fn serialize_tuple_struct(
134 self,
135 _name: &'static str,
136 _len: usize,
137 ) -> Result<Self::SerializeTupleStruct> {
138 Ok(Compound { ser: self })
139 }
140
141 fn serialize_tuple_variant(
142 self,
143 _name: &'static str,
144 _variant_index: u32,
145 _variant: &'static str,
146 _len: usize,
147 ) -> Result<Self::SerializeTupleVariant> {
148 BitcoinCodeError::MethodNotSupported("serialize_tuple_variant").into_err()
149 }
150
151 fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
152 let len = match len {
153 Some(len) => len,
154 None => return BitcoinCodeError::SequenceMustHaveLength.into_err(),
155 };
156 write_var_int(&mut self.writer, len as u64)?;
157 Ok(Compound { ser: self })
158 }
159
160 fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
161 Ok(Compound { ser: self })
162 }
163
164 fn serialize_struct_variant(
165 self,
166 _name: &'static str,
167 _variant_index: u32,
168 _variant: &'static str,
169 _len: usize,
170 ) -> Result<Self::SerializeStructVariant> {
171 BitcoinCodeError::MethodNotSupported("serialize_struct_variant").into_err()
172 }
173
174 fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> Result<()>
175 where
176 T: serde::ser::Serialize,
177 {
178 value.serialize(self)
179 }
180
181 fn serialize_newtype_variant<T: ?Sized>(
182 self,
183 _name: &'static str,
184 _variant_index: u32,
185 _variant: &'static str,
186 _value: &T,
187 ) -> Result<()>
188 where
189 T: serde::ser::Serialize,
190 {
191 BitcoinCodeError::MethodNotSupported("serialize_newtype_variant").into_err()
192 }
193
194 fn serialize_unit_variant(
195 self,
196 _name: &'static str,
197 _variant_index: u32,
198 _variant: &'static str,
199 ) -> Result<()> {
200 BitcoinCodeError::MethodNotSupported("serialize_unit_variant").into_err()
201 }
202
203 fn is_human_readable(&self) -> bool {
204 false
205 }
206}
207
208impl<'a, W: io::Write> serde::ser::SerializeSeq for Compound<'a, W> {
209 type Ok = ();
210 type Error = Error;
211
212 #[inline]
213 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
214 where
215 T: serde::ser::Serialize,
216 {
217 value.serialize(&mut *self.ser)
218 }
219
220 #[inline]
221 fn end(self) -> Result<()> {
222 Ok(())
223 }
224}
225
226impl<'a, W: io::Write> serde::ser::SerializeTuple for Compound<'a, W> {
227 type Ok = ();
228 type Error = Error;
229
230 #[inline]
231 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
232 where
233 T: serde::ser::Serialize,
234 {
235 value.serialize(&mut *self.ser)
236 }
237
238 #[inline]
239 fn end(self) -> Result<()> {
240 Ok(())
241 }
242}
243
244impl<'a, W: io::Write> serde::ser::SerializeTupleStruct for Compound<'a, W> {
245 type Ok = ();
246 type Error = Error;
247
248 #[inline]
249 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
250 where
251 T: serde::ser::Serialize,
252 {
253 value.serialize(&mut *self.ser)
254 }
255
256 #[inline]
257 fn end(self) -> Result<()> {
258 Ok(())
259 }
260}
261
262impl<'a, W: io::Write> serde::ser::SerializeTupleVariant for Compound<'a, W> {
263 type Ok = ();
264 type Error = Error;
265
266 #[inline]
267 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
268 where
269 T: serde::ser::Serialize,
270 {
271 value.serialize(&mut *self.ser)
272 }
273
274 #[inline]
275 fn end(self) -> Result<()> {
276 Ok(())
277 }
278}
279
280impl<'a, W: io::Write> serde::ser::SerializeMap for Compound<'a, W> {
281 type Ok = ();
282 type Error = Error;
283
284 #[inline]
285 fn serialize_key<K: ?Sized>(&mut self, value: &K) -> Result<()>
286 where
287 K: serde::ser::Serialize,
288 {
289 value.serialize(&mut *self.ser)
290 }
291
292 #[inline]
293 fn serialize_value<V: ?Sized>(&mut self, value: &V) -> Result<()>
294 where
295 V: serde::ser::Serialize,
296 {
297 value.serialize(&mut *self.ser)
298 }
299
300 #[inline]
301 fn end(self) -> Result<()> {
302 Ok(())
303 }
304}
305
306impl<'a, W: io::Write> serde::ser::SerializeStruct for Compound<'a, W> {
307 type Ok = ();
308 type Error = Error;
309
310 #[inline]
311 fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
312 where
313 T: serde::ser::Serialize,
314 {
315 value.serialize(&mut *self.ser)
316 }
317
318 #[inline]
319 fn end(self) -> Result<()> {
320 Ok(())
321 }
322}
323
324impl<'a, W: io::Write> serde::ser::SerializeStructVariant for Compound<'a, W> {
325 type Ok = ();
326 type Error = Error;
327
328 #[inline]
329 fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
330 where
331 T: serde::ser::Serialize,
332 {
333 value.serialize(&mut *self.ser)
334 }
335
336 #[inline]
337 fn end(self) -> Result<()> {
338 Ok(())
339 }
340}
341
342pub fn encode_bitcoin_code<T>(value: &T) -> Result<Vec<u8>>
343where
344 T: serde::ser::Serialize,
345{
346 let mut vec = Vec::new();
347 let mut serializer = Serializer { writer: &mut vec };
348 value.serialize(&mut serializer)?;
349 Ok(vec)
350}
351
352pub fn encode_bitcoin_code_all<'a, T: 'a>(
353 values: impl IntoIterator<Item = &'a T>,
354) -> Result<Vec<u8>>
355where
356 T: serde::ser::Serialize,
357{
358 let mut vec = Vec::new();
359 let mut serializer = Serializer { writer: &mut vec };
360 for value in values {
361 value.serialize(&mut serializer)?;
362 }
363 Ok(vec)
364}