serde_fleece/
ser.rs

1macro_rules! encoder_write {
2    ($this:expr, $func:ident $(, $arg:expr)*) => {
3        unsafe {
4            if $func($this.inner.as_ptr(), $($arg)*) {
5                Ok(())
6            } else {
7                Err(Error::from(FLEncoder_GetError($this.inner.as_ptr())))
8            }
9        }
10    };
11}
12
13mod macros;
14mod map;
15
16pub use macros::EncodeValue;
17
18use self::map::MapKeySerializer;
19use crate::{
20    error::Error,
21    ffi::{
22        FLEncoder_BeginArray, FLEncoder_BeginDict, FLEncoder_ConvertJSON, FLEncoder_EndArray,
23        FLEncoder_EndDict, FLEncoder_Finish, FLEncoder_Free, FLEncoder_GetError, FLEncoder_New,
24        FLEncoder_Reset, FLEncoder_WriteBool, FLEncoder_WriteDouble, FLEncoder_WriteFloat,
25        FLEncoder_WriteInt, FLEncoder_WriteKey, FLEncoder_WriteNull, FLEncoder_WriteString,
26        FLEncoder_WriteUInt, FLError, FLSliceResult, _FLEncoder,
27    },
28};
29use serde::{ser, Serialize};
30use std::{borrow::Borrow, fmt::Display, ptr::NonNull};
31
32pub(crate) struct Serializer {
33    inner: NonNull<_FLEncoder>,
34}
35
36/// Helper struct for multiple uses of `FLEncoder`
37pub struct FlEncoderSession {
38    inner: NonNull<_FLEncoder>,
39}
40
41impl FlEncoderSession {
42    #[inline]
43    pub fn new(inner: NonNull<_FLEncoder>) -> Self {
44        Self { inner }
45    }
46}
47
48impl Drop for FlEncoderSession {
49    #[inline]
50    fn drop(&mut self) {
51        unsafe { FLEncoder_Reset(self.inner.as_ptr()) }
52    }
53}
54
55impl Borrow<NonNull<_FLEncoder>> for FlEncoderSession {
56    #[inline]
57    fn borrow(&self) -> &NonNull<_FLEncoder> {
58        &self.inner
59    }
60}
61
62#[inline]
63pub fn to_fl_slice_result<T>(value: &T) -> Result<FLSliceResult, Error>
64where
65    T: Serialize,
66{
67    let enc =
68        unsafe { NonNull::new(FLEncoder_New()).ok_or(Error::Fleece(FLError::kFLMemoryError))? };
69    let ret = to_fl_slice_result_with_encoder(value, enc);
70    unsafe { FLEncoder_Free(enc.as_ptr()) };
71    ret
72}
73
74pub fn to_fl_slice_result_with_encoder<T, FleeceEncoder>(
75    value: &T,
76    encoder: FleeceEncoder,
77) -> Result<FLSliceResult, Error>
78where
79    T: Serialize,
80    FleeceEncoder: Borrow<NonNull<_FLEncoder>>,
81{
82    let mut serializer = Serializer {
83        inner: *encoder.borrow(),
84    };
85    value.serialize(&mut serializer)?;
86    let mut err = FLError::kFLNoError;
87    let ret = unsafe { FLEncoder_Finish(serializer.inner.as_ptr(), &mut err) };
88    if !ret.is_empty() {
89        Ok(ret)
90    } else {
91        Err(err.into())
92    }
93}
94
95/// Convert json data into fleece encoded byte array
96pub fn json_to_fleece_with_encoder<FleeceEncoder>(
97    json: &[u8],
98    encoder: FleeceEncoder,
99) -> Result<FLSliceResult, Error>
100where
101    FleeceEncoder: Borrow<NonNull<_FLEncoder>>,
102{
103    let serializer = Serializer {
104        inner: *encoder.borrow(),
105    };
106    if !unsafe { FLEncoder_ConvertJSON(serializer.inner.as_ptr(), json.into()) } {
107        return Err(Error::Fleece(FLError::kFLEncodeError));
108    }
109    let mut err = FLError::kFLNoError;
110    let ret = unsafe { FLEncoder_Finish(serializer.inner.as_ptr(), &mut err) };
111    if !ret.is_empty() {
112        Ok(ret)
113    } else {
114        Err(err.into())
115    }
116}
117
118impl<'a> ser::Serializer for &'a mut Serializer {
119    type Ok = ();
120    type Error = Error;
121
122    type SerializeSeq = Self;
123    type SerializeTuple = Self;
124    type SerializeTupleStruct = Self;
125    type SerializeTupleVariant = Self;
126    type SerializeMap = MapKeySerializer<'a>;
127    type SerializeStruct = Self;
128    type SerializeStructVariant = Self;
129
130    #[inline]
131    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
132        encoder_write!(self, FLEncoder_WriteBool, v)
133    }
134    #[inline]
135    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
136        let v = i64::from(v);
137        encoder_write!(self, FLEncoder_WriteInt, v)
138    }
139    #[inline]
140    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
141        encoder_write!(self, FLEncoder_WriteInt, i64::from(v))
142    }
143    #[inline]
144    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
145        encoder_write!(self, FLEncoder_WriteInt, i64::from(v))
146    }
147    #[inline]
148    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
149        encoder_write!(self, FLEncoder_WriteInt, v)
150    }
151    #[inline]
152    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
153        encoder_write!(self, FLEncoder_WriteUInt, u64::from(v))
154    }
155    #[inline]
156    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
157        encoder_write!(self, FLEncoder_WriteUInt, u64::from(v))
158    }
159    #[inline]
160    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
161        encoder_write!(self, FLEncoder_WriteUInt, u64::from(v))
162    }
163    #[inline]
164    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
165        encoder_write!(self, FLEncoder_WriteUInt, v)
166    }
167    #[inline]
168    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
169        encoder_write!(self, FLEncoder_WriteFloat, v)
170    }
171    #[inline]
172    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
173        encoder_write!(self, FLEncoder_WriteDouble, v)
174    }
175    #[inline]
176    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
177        let mut tmp = [0u8; 4];
178        let s: &str = v.encode_utf8(&mut tmp);
179        encoder_write!(self, FLEncoder_WriteString, s.into())
180    }
181    #[inline]
182    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
183        encoder_write!(self, FLEncoder_WriteString, v.into())
184    }
185    #[inline]
186    fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
187        Err(Error::Unsupported("Write raw bytes unsupported"))
188    }
189    #[inline]
190    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
191        encoder_write!(self, FLEncoder_WriteNull)
192    }
193    #[inline]
194    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
195    where
196        T: ?Sized + Serialize,
197    {
198        value.serialize(&mut *self)
199    }
200    #[inline]
201    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
202        encoder_write!(self, FLEncoder_WriteNull)
203    }
204    #[inline]
205    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
206        encoder_write!(self, FLEncoder_WriteNull)
207    }
208    #[inline]
209    fn serialize_unit_variant(
210        self,
211        _name: &'static str,
212        _variant_index: u32,
213        variant: &'static str,
214    ) -> Result<Self::Ok, Self::Error> {
215        encoder_write!(self, FLEncoder_WriteString, variant.into())
216    }
217    #[inline]
218    fn serialize_newtype_struct<T>(
219        self,
220        _name: &'static str,
221        value: &T,
222    ) -> Result<Self::Ok, Self::Error>
223    where
224        T: ?Sized + Serialize,
225    {
226        value.serialize(&mut *self)
227    }
228    #[inline]
229    fn serialize_newtype_variant<T>(
230        self,
231        _name: &'static str,
232        _variant_index: u32,
233        variant: &'static str,
234        value: &T,
235    ) -> Result<Self::Ok, Self::Error>
236    where
237        T: ?Sized + Serialize,
238    {
239        encoder_write!(self, FLEncoder_BeginDict, 1)?;
240        encoder_write!(self, FLEncoder_WriteKey, variant.into())?;
241        value.serialize(&mut *self)?;
242        encoder_write!(self, FLEncoder_EndDict)
243    }
244    #[inline]
245    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
246        encoder_write!(self, FLEncoder_BeginArray, len.unwrap_or(0))?;
247        Ok(self)
248    }
249    #[inline]
250    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
251        encoder_write!(self, FLEncoder_BeginArray, len)?;
252        Ok(self)
253    }
254    #[inline]
255    fn serialize_tuple_struct(
256        self,
257        _name: &'static str,
258        len: usize,
259    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
260        encoder_write!(self, FLEncoder_BeginArray, len)?;
261        Ok(self)
262    }
263    #[inline]
264    fn serialize_tuple_variant(
265        self,
266        _name: &'static str,
267        _variant_index: u32,
268        variant: &'static str,
269        len: usize,
270    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
271        encoder_write!(self, FLEncoder_BeginDict, 1)?;
272        encoder_write!(self, FLEncoder_WriteKey, variant.into())?;
273        encoder_write!(self, FLEncoder_BeginArray, len)?;
274        Ok(self)
275    }
276    #[inline]
277    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
278        encoder_write!(self, FLEncoder_BeginDict, len.unwrap_or(0))?;
279        Ok(MapKeySerializer { ser: self })
280    }
281    #[inline]
282    fn serialize_struct(
283        self,
284        _name: &'static str,
285        len: usize,
286    ) -> Result<Self::SerializeStruct, Self::Error> {
287        encoder_write!(self, FLEncoder_BeginDict, len)?;
288        Ok(self)
289    }
290    #[inline]
291    fn serialize_struct_variant(
292        self,
293        _name: &'static str,
294        _variant_index: u32,
295        variant: &'static str,
296        len: usize,
297    ) -> Result<Self::SerializeStructVariant, Self::Error> {
298        encoder_write!(self, FLEncoder_BeginDict, 1)?;
299        encoder_write!(self, FLEncoder_WriteKey, variant.into())?;
300        encoder_write!(self, FLEncoder_BeginDict, len)?;
301        Ok(self)
302    }
303    #[inline]
304    fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
305    where
306        T: ?Sized + Display,
307    {
308        self.serialize_str(&value.to_string())
309    }
310}
311
312impl ser::SerializeSeq for &mut Serializer {
313    type Ok = ();
314    type Error = Error;
315
316    /// Serialize a single element of the sequence.
317    #[inline]
318    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
319    where
320        T: ?Sized + Serialize,
321    {
322        value.serialize(&mut **self)
323    }
324
325    /// Close the sequence.
326    #[inline]
327    fn end(self) -> Result<(), Self::Error> {
328        encoder_write!(self, FLEncoder_EndArray)
329    }
330}
331
332impl ser::SerializeTuple for &mut Serializer {
333    type Ok = ();
334    type Error = Error;
335
336    #[inline]
337    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
338    where
339        T: ?Sized + Serialize,
340    {
341        value.serialize(&mut **self)
342    }
343
344    #[inline]
345    fn end(self) -> Result<(), Self::Error> {
346        encoder_write!(self, FLEncoder_EndArray)
347    }
348}
349
350impl ser::SerializeTupleStruct for &mut Serializer {
351    type Ok = ();
352    type Error = Error;
353
354    #[inline]
355    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
356    where
357        T: ?Sized + Serialize,
358    {
359        value.serialize(&mut **self)
360    }
361    #[inline]
362    fn end(self) -> Result<(), Self::Error> {
363        encoder_write!(self, FLEncoder_EndArray)
364    }
365}
366
367/// Tuple variants are a little different. Refer back to the
368/// `serialize_tuple_variant` method above:
369///
370///    self.output += "{";
371///    variant.serialize(&mut *self)?;
372///    self.output += ":[";
373///
374/// So the `end` method in this impl is responsible for closing both the `]` and
375/// the `}`.
376impl ser::SerializeTupleVariant for &mut Serializer {
377    type Ok = ();
378    type Error = Error;
379
380    #[inline]
381    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
382    where
383        T: ?Sized + Serialize,
384    {
385        value.serialize(&mut **self)
386    }
387
388    #[inline]
389    fn end(self) -> Result<(), Self::Error> {
390        encoder_write!(self, FLEncoder_EndArray)?;
391        encoder_write!(self, FLEncoder_EndDict)
392    }
393}
394
395/// Structs are like maps in which the keys are constrained to be compile-time
396/// constant strings.
397impl ser::SerializeStruct for &mut Serializer {
398    type Ok = ();
399    type Error = Error;
400
401    #[inline]
402    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
403    where
404        T: ?Sized + Serialize,
405    {
406        encoder_write!(self, FLEncoder_WriteKey, key.into())?;
407        value.serialize(&mut **self)
408    }
409
410    #[inline]
411    fn end(self) -> Result<(), Self::Error> {
412        encoder_write!(self, FLEncoder_EndDict)
413    }
414}
415
416/// Similar to `SerializeTupleVariant`, here the `end` method is responsible for
417/// closing both of the curly braces opened by `serialize_struct_variant`.
418impl ser::SerializeStructVariant for &mut Serializer {
419    type Ok = ();
420    type Error = Error;
421
422    #[inline]
423    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
424    where
425        T: ?Sized + Serialize,
426    {
427        encoder_write!(self, FLEncoder_WriteKey, key.into())?;
428        value.serialize(&mut **self)
429    }
430
431    #[inline]
432    fn end(self) -> Result<(), Self::Error> {
433        encoder_write!(self, FLEncoder_EndDict)?;
434        encoder_write!(self, FLEncoder_EndDict)
435    }
436}
serde_fleece/ser.rs

serde_fleece/
ser.rs
