ruby_marshal/serialize/
mod.rs

1#![allow(unused_variables)]
2#![allow(dead_code)]
3#![allow(unused_must_use)]
4
5use crate::error::{Error, Result};
6use num_traits::int::PrimInt;
7use serde::{ser, Serialize};
8
9pub struct Serializer {
10    output: Vec<u8>,
11}
12
13// TODO
14pub fn to_bytes<T>(value: &T) -> Result<Vec<u8>>
15where
16    T: Serialize,
17{
18    let mut serializer = Serializer {
19        output: vec![0x4, 0x8], // The first two bytes of ANY marshal data are 0x4 and 0x8.
20                                // Those two butes are a version specifier. Most ruby versions
21                                // support version 48. (hence 0x4 0x8)
22                                // Marshal version 48 is so old even RMXP uses it.
23    };
24    value.serialize(&mut serializer)?;
25    Ok(serializer.output)
26}
27
28impl Serializer {
29    fn process_digit<T>(&mut self, d: T) -> Result<()>
30    where
31        T: PrimInt,
32    {
33        self.output.push(b'i');
34        match d.to_i128() {
35            // Serialization of `long` values
36            Some(mut i) => {
37                if i == 0 {
38                    self.output.push(0x0);
39                } else if 0 < i && i < 123 {
40                    self.output.push((i + 5) as u8);
41                } else if -124 < i && i < 0 {
42                    self.output.push(((i - 5) & 0xff) as u8);
43                }
44
45                let mut chars: Vec<u8> = Vec::new();
46                for ii in 0..i32::BITS as i32 {
47                    chars.push((i & 0xff) as u8);
48                    i = i << 8;
49                    if i == 0 {
50                        chars[0] = ii as u8;
51                        break;
52                    }
53                    if i == -1 {
54                        chars[0] = -ii as u8;
55                        break;
56                    }
57                }
58            }
59            None => {}
60        }
61        Ok(())
62    }
63
64    fn write_rstr(&mut self, v: &str) {
65        for character in v.bytes() {
66            self.output.push(character);
67        }
68    }
69}
70
71impl<'a> ser::Serializer for &'a mut Serializer {
72    type Ok = ();
73    type Error = Error;
74
75    // No additional state is required beyond what is already stored in the
76    // Serializer struct.
77    type SerializeSeq = Self;
78    type SerializeTuple = Self;
79    type SerializeTupleStruct = Self;
80    type SerializeTupleVariant = Self;
81    type SerializeMap = Self;
82    type SerializeStruct = Self;
83    type SerializeStructVariant = Self;
84
85    // ! Implemented
86
87    // This function is easy, because all marshal expects is a T or an F,
88    fn serialize_bool(self, v: bool) -> Result<()> {
89        self.output.push(if v { b'T' } else { b'F' });
90        Ok(())
91    }
92
93    // An optional is just serialized as its value.
94    fn serialize_some<T>(self, value: &T) -> Result<()>
95    where
96        T: ?Sized + Serialize,
97    {
98        value.serialize(self)
99    }
100
101    // Super simple. An optional None is nil. nil is 0.
102    fn serialize_none(self) -> Result<()> {
103        self.output.push(0x0);
104        Ok(())
105    }
106
107    // Maps to nil.
108    fn serialize_unit(self) -> Result<()> {
109        self.serialize_none()
110    }
111
112    fn serialize_i8(self, v: i8) -> Result<()> {
113        self.process_digit(v)
114    }
115
116    fn serialize_i16(self, v: i16) -> Result<()> {
117        self.process_digit(v)
118    }
119
120    fn serialize_i32(self, v: i32) -> Result<()> {
121        self.process_digit(v)
122    }
123
124    fn serialize_i64(self, v: i64) -> Result<()> {
125        self.process_digit(v)
126    }
127
128    fn serialize_i128(self, v: i128) -> Result<()> {
129        self.process_digit(v)
130    }
131
132    fn serialize_u8(self, v: u8) -> Result<()> {
133        self.process_digit(v)
134    }
135
136    fn serialize_u16(self, v: u16) -> Result<()> {
137        self.process_digit(v)
138    }
139
140    fn serialize_u32(self, v: u32) -> Result<()> {
141        self.process_digit(v)
142    }
143
144    fn serialize_u64(self, v: u64) -> Result<()> {
145        self.process_digit(v)
146    }
147
148    fn serialize_u128(self, v: u128) -> Result<()> {
149        self.process_digit(v)
150    }
151
152    fn serialize_f32(self, v: f32) -> Result<()> {
153        self.serialize_f64(v as f64)
154    }
155
156    fn serialize_f64(self, v: f64) -> Result<()> {
157        if v.is_infinite() || v.is_nan() || v == 0.0 {
158            if v.is_infinite() {
159                if v < 0.0 {
160                    self.write_rstr("-inf");
161                } else {
162                    self.write_rstr("inf");
163                }
164            } else if v.is_nan() {
165                self.write_rstr("nan");
166            } else if v == 0.0 {
167                self.write_rstr("0");
168            }
169            return Ok(());
170        }
171
172        let dtoa = v.to_string();
173
174        Ok(())
175    }
176
177    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
178        self.serialize_unit()
179    }
180
181    fn serialize_char(self, v: char) -> Result<()> {
182        self.serialize_str(v.to_string().as_str())
183    }
184
185    fn serialize_str(self, v: &str) -> Result<()> {
186        Ok(())
187    }
188
189    fn serialize_bytes(self, v: &[u8]) -> Result<()> {
190        for byte in v {
191            self.output.push(*byte);
192        }
193        Ok(())
194    }
195
196    fn serialize_unit_variant(
197        self,
198        _name: &'static str,
199        _variant_index: u32,
200        variant: &'static str,
201    ) -> Result<()> {
202        Ok(())
203    }
204
205    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<()>
206    where
207        T: ?Sized + Serialize,
208    {
209        Ok(())
210    }
211
212    fn serialize_newtype_variant<T>(
213        self,
214        _name: &'static str,
215        _variant_index: u32,
216        variant: &'static str,
217        value: &T,
218    ) -> Result<()>
219    where
220        T: ?Sized + Serialize,
221    {
222        Ok(())
223    }
224
225    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
226        Ok(self)
227    }
228
229    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
230        self.serialize_seq(Some(len))
231    }
232
233    fn serialize_tuple_struct(
234        self,
235        _name: &'static str,
236        len: usize,
237    ) -> Result<Self::SerializeTupleStruct> {
238        self.serialize_seq(Some(len))
239    }
240
241    fn serialize_tuple_variant(
242        self,
243        _name: &'static str,
244        _variant_index: u32,
245        variant: &'static str,
246        _len: usize,
247    ) -> Result<Self::SerializeTupleVariant> {
248        Ok(self)
249    }
250
251    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
252        Ok(self)
253    }
254
255    fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
256        Ok(self)
257    }
258
259    fn serialize_struct_variant(
260        self,
261        _name: &'static str,
262        _variant_index: u32,
263        variant: &'static str,
264        _len: usize,
265    ) -> Result<Self::SerializeStructVariant> {
266        Ok(self)
267    }
268}
269
270impl<'a> ser::SerializeSeq for &'a mut Serializer {
271    type Ok = ();
272    type Error = Error;
273
274    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
275    where
276        T: ?Sized + Serialize,
277    {
278        value.serialize(&mut **self)
279    }
280
281    // Close the sequence.
282    fn end(self) -> Result<()> {
283        Ok(())
284    }
285}
286
287impl<'a> ser::SerializeTuple for &'a mut Serializer {
288    type Ok = ();
289    type Error = Error;
290
291    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
292    where
293        T: ?Sized + Serialize,
294    {
295        value.serialize(&mut **self)
296    }
297
298    fn end(self) -> Result<()> {
299        Ok(())
300    }
301}
302
303impl<'a> ser::SerializeTupleStruct for &'a mut Serializer {
304    type Ok = ();
305    type Error = Error;
306
307    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
308    where
309        T: ?Sized + Serialize,
310    {
311        value.serialize(&mut **self)
312    }
313
314    fn end(self) -> Result<()> {
315        Ok(())
316    }
317}
318
319impl<'a> ser::SerializeTupleVariant for &'a mut Serializer {
320    type Ok = ();
321    type Error = Error;
322
323    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
324    where
325        T: ?Sized + Serialize,
326    {
327        value.serialize(&mut **self)
328    }
329
330    fn end(self) -> Result<()> {
331        Ok(())
332    }
333}
334
335impl<'a> ser::SerializeMap for &'a mut Serializer {
336    type Ok = ();
337    type Error = Error;
338
339    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
340    where
341        T: ?Sized + Serialize,
342    {
343        key.serialize(&mut **self)
344    }
345
346    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
347    where
348        T: ?Sized + Serialize,
349    {
350        value.serialize(&mut **self)
351    }
352
353    fn end(self) -> Result<()> {
354        Ok(())
355    }
356}
357
358impl<'a> ser::SerializeStruct for &'a mut Serializer {
359    type Ok = ();
360    type Error = Error;
361
362    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
363    where
364        T: ?Sized + Serialize,
365    {
366        key.serialize(&mut **self)?;
367        value.serialize(&mut **self)
368    }
369
370    fn end(self) -> Result<()> {
371        Ok(())
372    }
373}
374
375impl<'a> ser::SerializeStructVariant for &'a mut Serializer {
376    type Ok = ();
377    type Error = Error;
378
379    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
380    where
381        T: ?Sized + Serialize,
382    {
383        key.serialize(&mut **self)?;
384        value.serialize(&mut **self)
385    }
386
387    fn end(self) -> Result<()> {
388        Ok(())
389    }
390}
ruby_marshal/serialize/mod.rs

ruby_marshal/serialize/
mod.rs
