Skip to main content

arrow_json/reader/
serializer.rs

1// SPDX-License-Identifier: Apache-2.0
2// SPDX-FileCopyrightText: See the NOTICE file distributed with this work for additional information regarding copyright ownership
3// SPDX-FileContributor: Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements
4
5use crate::reader::tape::TapeElement;
6use lexical_core::FormattedSize;
7use serde_core::ser::{
8    Impossible, SerializeMap, SerializeSeq, SerializeStruct, SerializeTuple, SerializeTupleStruct,
9};
10use serde_core::{Serialize, Serializer};
11
12#[derive(Debug)]
13pub struct SerializerError(String);
14
15impl std::error::Error for SerializerError {}
16
17impl std::fmt::Display for SerializerError {
18    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19        write!(f, "{}", self.0)
20    }
21}
22
23impl serde_core::ser::Error for SerializerError {
24    fn custom<T>(msg: T) -> Self
25    where
26        T: std::fmt::Display,
27    {
28        Self(msg.to_string())
29    }
30}
31
32/// [`Serializer`] for [`TapeElement`]
33///
34/// Heavily based on <https://serde.rs/impl-serializer.html>
35pub struct TapeSerializer<'a> {
36    elements: &'a mut Vec<TapeElement>,
37
38    /// A buffer of parsed string data
39    bytes: &'a mut Vec<u8>,
40
41    /// Offsets into `data`
42    offsets: &'a mut Vec<usize>,
43}
44
45impl<'a> TapeSerializer<'a> {
46    pub fn new(
47        elements: &'a mut Vec<TapeElement>,
48        bytes: &'a mut Vec<u8>,
49        offsets: &'a mut Vec<usize>,
50    ) -> Self {
51        Self {
52            elements,
53            bytes,
54            offsets,
55        }
56    }
57
58    fn serialize_number(&mut self, v: &[u8]) {
59        self.bytes.extend_from_slice(v);
60        let idx = self.offsets.len() - 1;
61        self.elements.push(TapeElement::Number(idx as _));
62        self.offsets.push(self.bytes.len());
63    }
64}
65
66impl<'a, 'b> Serializer for &'a mut TapeSerializer<'b> {
67    type Ok = ();
68
69    type Error = SerializerError;
70
71    type SerializeSeq = ListSerializer<'a, 'b>;
72    type SerializeTuple = ListSerializer<'a, 'b>;
73    type SerializeTupleStruct = ListSerializer<'a, 'b>;
74    type SerializeTupleVariant = Impossible<(), SerializerError>;
75    type SerializeMap = ObjectSerializer<'a, 'b>;
76    type SerializeStruct = ObjectSerializer<'a, 'b>;
77    type SerializeStructVariant = Impossible<(), SerializerError>;
78
79    fn serialize_bool(self, v: bool) -> Result<(), SerializerError> {
80        self.elements.push(match v {
81            true => TapeElement::True,
82            false => TapeElement::False,
83        });
84        Ok(())
85    }
86
87    fn serialize_i8(self, v: i8) -> Result<(), SerializerError> {
88        self.serialize_i32(v as _)
89    }
90
91    fn serialize_i16(self, v: i16) -> Result<(), SerializerError> {
92        self.serialize_i32(v as _)
93    }
94
95    fn serialize_i32(self, v: i32) -> Result<(), SerializerError> {
96        self.elements.push(TapeElement::I32(v));
97        Ok(())
98    }
99
100    fn serialize_i64(self, v: i64) -> Result<(), SerializerError> {
101        let low = v as i32;
102        let high = (v >> 32) as i32;
103        self.elements.push(TapeElement::I64(high));
104        self.elements.push(TapeElement::I32(low));
105        Ok(())
106    }
107
108    fn serialize_u8(self, v: u8) -> Result<(), SerializerError> {
109        self.serialize_i32(v as _)
110    }
111
112    fn serialize_u16(self, v: u16) -> Result<(), SerializerError> {
113        self.serialize_i32(v as _)
114    }
115
116    fn serialize_u32(self, v: u32) -> Result<(), SerializerError> {
117        match i32::try_from(v) {
118            Ok(v) => self.serialize_i32(v),
119            Err(_) => self.serialize_i64(v as _),
120        }
121    }
122
123    fn serialize_u64(self, v: u64) -> Result<(), SerializerError> {
124        match i64::try_from(v) {
125            Ok(v) => self.serialize_i64(v),
126            Err(_) => {
127                let mut buffer = [0_u8; u64::FORMATTED_SIZE];
128                let s = lexical_core::write(v, &mut buffer);
129                self.serialize_number(s);
130                Ok(())
131            }
132        }
133    }
134
135    fn serialize_f32(self, v: f32) -> Result<(), SerializerError> {
136        self.elements.push(TapeElement::F32(v.to_bits()));
137        Ok(())
138    }
139
140    fn serialize_f64(self, v: f64) -> Result<(), SerializerError> {
141        let bits = v.to_bits();
142        self.elements.push(TapeElement::F64((bits >> 32) as u32));
143        self.elements.push(TapeElement::F32(bits as u32));
144        Ok(())
145    }
146
147    fn serialize_char(self, v: char) -> Result<(), SerializerError> {
148        self.serialize_str(&v.to_string())
149    }
150
151    fn serialize_str(self, v: &str) -> Result<(), SerializerError> {
152        self.serialize_bytes(v.as_bytes())
153    }
154
155    fn serialize_bytes(self, v: &[u8]) -> Result<(), SerializerError> {
156        self.bytes.extend_from_slice(v);
157        let idx = self.offsets.len() - 1;
158        self.elements.push(TapeElement::String(idx as _));
159        self.offsets.push(self.bytes.len());
160        Ok(())
161    }
162
163    fn serialize_none(self) -> Result<(), SerializerError> {
164        self.serialize_unit()
165    }
166
167    fn serialize_some<T>(self, value: &T) -> Result<(), SerializerError>
168    where
169        T: ?Sized + Serialize,
170    {
171        value.serialize(self)
172    }
173
174    fn serialize_unit(self) -> Result<(), SerializerError> {
175        self.elements.push(TapeElement::Null);
176        Ok(())
177    }
178
179    fn serialize_unit_struct(self, _name: &'static str) -> Result<(), SerializerError> {
180        self.serialize_unit()
181    }
182
183    fn serialize_unit_variant(
184        self,
185        _name: &'static str,
186        _variant_index: u32,
187        variant: &'static str,
188    ) -> Result<(), SerializerError> {
189        self.serialize_str(variant)
190    }
191
192    fn serialize_newtype_struct<T>(
193        self,
194        _name: &'static str,
195        value: &T,
196    ) -> Result<(), SerializerError>
197    where
198        T: ?Sized + Serialize,
199    {
200        value.serialize(self)
201    }
202
203    fn serialize_newtype_variant<T>(
204        self,
205        _name: &'static str,
206        _variant_index: u32,
207        variant: &'static str,
208        value: &T,
209    ) -> Result<(), SerializerError>
210    where
211        T: ?Sized + Serialize,
212    {
213        let mut serializer = self.serialize_map(Some(1))?;
214        serializer.serialize_key(variant)?;
215        serializer.serialize_value(value)?;
216        serializer.finish();
217        Ok(())
218    }
219
220    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, SerializerError> {
221        Ok(ListSerializer::new(self))
222    }
223
224    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, SerializerError> {
225        self.serialize_seq(Some(len))
226    }
227
228    fn serialize_tuple_struct(
229        self,
230        _name: &'static str,
231        len: usize,
232    ) -> Result<Self::SerializeTupleStruct, SerializerError> {
233        self.serialize_seq(Some(len))
234    }
235
236    fn serialize_tuple_variant(
237        self,
238        name: &'static str,
239        _variant_index: u32,
240        variant: &'static str,
241        _len: usize,
242    ) -> Result<Self::SerializeTupleVariant, SerializerError> {
243        Err(SerializerError(format!(
244            "serializing tuple variants is not currently supported: {name}::{variant}"
245        )))
246    }
247
248    // Maps are represented in JSON as `{ K: V, K: V, ... }`.
249    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, SerializerError> {
250        Ok(ObjectSerializer::new(self))
251    }
252
253    fn serialize_struct(
254        self,
255        _name: &'static str,
256        len: usize,
257    ) -> Result<Self::SerializeStruct, SerializerError> {
258        self.serialize_map(Some(len))
259    }
260
261    fn serialize_struct_variant(
262        self,
263        name: &'static str,
264        _variant_index: u32,
265        variant: &'static str,
266        _len: usize,
267    ) -> Result<Self::SerializeStructVariant, SerializerError> {
268        Err(SerializerError(format!(
269            "serializing struct variants is not currently supported: {name}::{variant}"
270        )))
271    }
272}
273
274pub struct ObjectSerializer<'a, 'b> {
275    serializer: &'a mut TapeSerializer<'b>,
276    start: usize,
277}
278
279impl<'a, 'b> ObjectSerializer<'a, 'b> {
280    fn new(serializer: &'a mut TapeSerializer<'b>) -> Self {
281        let start = serializer.elements.len();
282        serializer.elements.push(TapeElement::StartObject(0));
283        Self { serializer, start }
284    }
285
286    fn finish(self) {
287        let end = self.serializer.elements.len() as _;
288        self.serializer.elements[self.start] = TapeElement::StartObject(end);
289
290        let end = TapeElement::EndObject(self.start as _);
291        self.serializer.elements.push(end);
292    }
293}
294
295impl SerializeMap for ObjectSerializer<'_, '_> {
296    type Ok = ();
297    type Error = SerializerError;
298
299    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
300    where
301        T: Serialize + ?Sized,
302    {
303        key.serialize(&mut *self.serializer)
304    }
305
306    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
307    where
308        T: Serialize + ?Sized,
309    {
310        value.serialize(&mut *self.serializer)
311    }
312
313    fn end(self) -> Result<(), Self::Error> {
314        self.finish();
315        Ok(())
316    }
317}
318
319impl SerializeStruct for ObjectSerializer<'_, '_> {
320    type Ok = ();
321    type Error = SerializerError;
322
323    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
324    where
325        T: Serialize + ?Sized,
326    {
327        key.serialize(&mut *self.serializer)?;
328        value.serialize(&mut *self.serializer)
329    }
330
331    fn end(self) -> Result<(), Self::Error> {
332        self.finish();
333        Ok(())
334    }
335}
336
337pub struct ListSerializer<'a, 'b> {
338    serializer: &'a mut TapeSerializer<'b>,
339    start: usize,
340}
341
342impl<'a, 'b> ListSerializer<'a, 'b> {
343    fn new(serializer: &'a mut TapeSerializer<'b>) -> Self {
344        let start = serializer.elements.len();
345        serializer.elements.push(TapeElement::StartList(0));
346        Self { serializer, start }
347    }
348
349    fn finish(self) {
350        let end = self.serializer.elements.len() as _;
351        self.serializer.elements[self.start] = TapeElement::StartList(end);
352
353        let end = TapeElement::EndList(self.start as _);
354        self.serializer.elements.push(end);
355    }
356}
357
358impl SerializeSeq for ListSerializer<'_, '_> {
359    type Ok = ();
360    type Error = SerializerError;
361
362    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
363    where
364        T: Serialize + ?Sized,
365    {
366        value.serialize(&mut *self.serializer)
367    }
368
369    fn end(self) -> Result<(), Self::Error> {
370        self.finish();
371        Ok(())
372    }
373}
374
375impl SerializeTuple for ListSerializer<'_, '_> {
376    type Ok = ();
377    type Error = SerializerError;
378
379    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
380    where
381        T: Serialize + ?Sized,
382    {
383        value.serialize(&mut *self.serializer)
384    }
385
386    fn end(self) -> Result<(), Self::Error> {
387        self.finish();
388        Ok(())
389    }
390}
391
392impl SerializeTupleStruct for ListSerializer<'_, '_> {
393    type Ok = ();
394    type Error = SerializerError;
395
396    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
397    where
398        T: Serialize + ?Sized,
399    {
400        value.serialize(&mut *self.serializer)
401    }
402
403    fn end(self) -> Result<(), Self::Error> {
404        self.finish();
405        Ok(())
406    }
407}