minio_rsc/xml/
ser.rs

1use std::io::{BufWriter, Write};
2
3use serde::Serialize;
4
5use super::error::Error;
6
7/// A convenience method for serializing some object to a buffer.
8#[inline]
9pub fn to_writer<W: Write, S: Serialize>(writer: W, value: &S) -> Result<(), Error> {
10    value.serialize(&mut Serializer::new(writer))
11}
12
13/// A convenience method for serializing some object to a string.
14pub fn to_string<S: Serialize>(value: &S) -> Result<String, Error> {
15    let mut writer = Vec::new();
16    to_writer(&mut writer, value)?;
17    String::from_utf8(writer).map_err(Into::into)
18}
19
20macro_rules! unsupport_type {
21    ($type_:expr) => {
22        Error::UnsupportedOperation {
23            operation: format!("Serializing {}", $type_),
24        }
25    };
26}
27
28macro_rules! serialize_num_attr {
29    ($name:ident, $type_:tt) => {
30        #[inline]
31        fn $name(self, v: $type_) -> Result<Self::Ok, Self::Error> {
32            self.serialize_str(&v.to_string())
33        }
34    };
35}
36
37struct Serializer<W>
38where
39    W: Write,
40{
41    writer: BufWriter<W>,
42    tags: Vec<&'static str>,
43}
44
45#[allow(unused)]
46impl<W> Serializer<W>
47where
48    W: Write,
49{
50    fn new(writer: W) -> Self {
51        Self {
52            writer: BufWriter::new(writer),
53            tags: vec![],
54        }
55    }
56
57    fn write_tag(&mut self) -> Result<(), Error> {
58        if let Some(tag) = self.tags.last() {
59            self.writer.write_fmt(format_args!("<{tag}>"))?;
60            Ok(())
61        } else {
62            Err(Error::Custom {
63                field: "serialize fail with empty tag".to_owned(),
64            })
65        }
66    }
67
68    fn write_close_tag(&mut self) -> Result<(), Error> {
69        if let Some(tag) = self.tags.last() {
70            self.writer.write_fmt(format_args!("</{tag}>"))?;
71            Ok(())
72        } else {
73            Err(Error::Custom {
74                field: "serialize fail with empty /tag".to_owned(),
75            })
76        }
77    }
78}
79
80#[allow(unused)]
81impl<'ser, W: Write> serde::ser::Serializer for &'ser mut Serializer<W> {
82    type Ok = ();
83    type Error = Error;
84
85    type SerializeSeq = Self;
86
87    type SerializeTuple = Self;
88
89    type SerializeTupleStruct = Self;
90
91    type SerializeTupleVariant = Self;
92
93    type SerializeMap = Self;
94
95    type SerializeStruct = Self;
96
97    type SerializeStructVariant = Self;
98
99    // fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
100    //     Err(unsupport_type!("bool"))
101    // }
102
103    serialize_num_attr!(serialize_bool, bool);
104    serialize_num_attr!(serialize_i8, i8);
105    serialize_num_attr!(serialize_i16, i16);
106    serialize_num_attr!(serialize_i32, i32);
107    serialize_num_attr!(serialize_i64, i64);
108    serialize_num_attr!(serialize_u8, u8);
109    serialize_num_attr!(serialize_u16, u16);
110    serialize_num_attr!(serialize_u32, u32);
111    serialize_num_attr!(serialize_u64, u64);
112    serialize_num_attr!(serialize_f32, f32);
113    serialize_num_attr!(serialize_f64, f64);
114    serialize_num_attr!(serialize_char, char);
115
116    #[inline]
117    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
118        self.serialize_bytes(v.as_bytes())
119    }
120
121    #[inline]
122    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
123        self.write_tag()?;
124        self.writer.write(v)?;
125        self.write_close_tag()?;
126        Ok(())
127    }
128
129    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
130        // skip none
131        Ok(())
132    }
133
134    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
135    where
136        T: serde::Serialize,
137    {
138        value.serialize(self)
139    }
140
141    /// The type of `()` in Rust.
142    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
143        // skip
144        Ok(())
145    }
146
147    /// `struct Unit` or `PhantomData<T>`. It represents a named value containing no data.
148    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
149        Err(unsupport_type!("unit_struct"))
150    }
151
152    /// For example the `E::A` and `E::B` in enum `E { A, B }`
153    fn serialize_unit_variant(
154        self,
155        name: &'static str,
156        variant_index: u32,
157        variant: &'static str,
158    ) -> Result<Self::Ok, Self::Error> {
159        self.serialize_str(variant)
160    }
161
162    /// For example `struct Millimeters(u8)`.
163    fn serialize_newtype_struct<T: ?Sized>(
164        self,
165        name: &'static str,
166        value: &T,
167    ) -> Result<Self::Ok, Self::Error>
168    where
169        T: serde::Serialize,
170    {
171        value.serialize(self)
172    }
173
174    /// For example the `E::N` in enum `E { N(u8) }`
175    fn serialize_newtype_variant<T: ?Sized>(
176        self,
177        name: &'static str,
178        variant_index: u32,
179        variant: &'static str,
180        value: &T,
181    ) -> Result<Self::Ok, Self::Error>
182    where
183        T: serde::Serialize,
184    {
185        Err(unsupport_type!("newtype_variant"))
186    }
187
188    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
189        Ok(self)
190    }
191
192    /// A statically sized heterogeneous sequence of values for which the length will
193    /// be known at deserialization time without looking at the serialized data,
194    /// for example `(u8,)` or `(String, u64, Vec<T>)` or `[u64; 10]`.
195    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
196        Err(unsupport_type!("tuple"))
197    }
198
199    /// A named tuple, for example `struct Rgb(u8, u8, u8)`.
200    fn serialize_tuple_struct(
201        self,
202        name: &'static str,
203        len: usize,
204    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
205        Err(unsupport_type!("tuple_struct"))
206    }
207
208    /// For example the `E::T` in `enum E { T(u8, u8) }`.
209    fn serialize_tuple_variant(
210        self,
211        name: &'static str,
212        variant_index: u32,
213        variant: &'static str,
214        len: usize,
215    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
216        Err(unsupport_type!("tuple_variant"))
217    }
218
219    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
220        Err(unsupport_type!("map"))
221    }
222
223    fn serialize_struct(
224        self,
225        name: &'static str,
226        len: usize,
227    ) -> Result<Self::SerializeStruct, Self::Error> {
228        if self.tags.len() == 0 {
229            self.tags.push(name);
230        }
231        self.write_tag();
232        Ok(self)
233    }
234
235    /// For example the `E::S` in `enum E { S { r: u8, g: u8, b: u8 } }`.
236    fn serialize_struct_variant(
237        self,
238        name: &'static str,
239        variant_index: u32,
240        variant: &'static str,
241        len: usize,
242    ) -> Result<Self::SerializeStructVariant, Self::Error> {
243        Err(unsupport_type!("struct_variant"))
244    }
245}
246
247impl<'ser, W: Write> serde::ser::SerializeSeq for &'ser mut Serializer<W> {
248    type Ok = ();
249
250    type Error = Error;
251
252    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
253    where
254        T: serde::Serialize,
255    {
256        value.serialize(&mut **self)
257    }
258
259    fn end(self) -> Result<Self::Ok, Self::Error> {
260        Ok(())
261    }
262}
263
264#[allow(unused)]
265impl<'ser, W: Write> serde::ser::SerializeMap for &'ser mut Serializer<W> {
266    type Ok = ();
267
268    type Error = Error;
269
270    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
271    where
272        T: serde::Serialize,
273    {
274        Err(unsupport_type!("Map"))
275    }
276
277    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
278    where
279        T: serde::Serialize,
280    {
281        Err(unsupport_type!("Map"))
282    }
283
284    fn end(self) -> Result<Self::Ok, Self::Error> {
285        Err(unsupport_type!("Map"))
286    }
287}
288
289#[allow(unused)]
290impl<'ser, W: Write> serde::ser::SerializeTuple for &'ser mut Serializer<W> {
291    type Ok = ();
292
293    type Error = Error;
294
295    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
296    where
297        T: serde::Serialize,
298    {
299        Err(unsupport_type!("Tuple"))
300    }
301
302    fn end(self) -> Result<Self::Ok, Self::Error> {
303        Err(unsupport_type!("Tuple"))
304    }
305}
306
307#[allow(unused)]
308impl<'ser, W: Write> serde::ser::SerializeTupleStruct for &'ser mut Serializer<W> {
309    type Ok = ();
310
311    type Error = Error;
312
313    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
314    where
315        T: serde::Serialize,
316    {
317        Err(unsupport_type!("TupleStruct"))
318    }
319
320    fn end(self) -> Result<Self::Ok, Self::Error> {
321        Err(unsupport_type!("TupleStruct"))
322    }
323}
324
325#[allow(unused)]
326impl<'ser, W: Write> serde::ser::SerializeTupleVariant for &'ser mut Serializer<W> {
327    type Ok = ();
328
329    type Error = Error;
330
331    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
332    where
333        T: serde::Serialize,
334    {
335        Err(unsupport_type!("TupleVariant"))
336    }
337
338    fn end(self) -> Result<Self::Ok, Self::Error> {
339        Err(unsupport_type!("TupleVariant"))
340    }
341}
342
343impl<'ser, W: Write> serde::ser::SerializeStruct for &'ser mut Serializer<W> {
344    type Ok = ();
345
346    type Error = Error;
347
348    fn serialize_field<T: ?Sized>(
349        &mut self,
350        key: &'static str,
351        value: &T,
352    ) -> Result<(), Self::Error>
353    where
354        T: serde::Serialize,
355    {
356        self.tags.push(key);
357        value.serialize(&mut **self)?;
358        self.tags.pop();
359        Ok(())
360    }
361
362    fn end(self) -> Result<Self::Ok, Self::Error> {
363        self.write_close_tag()
364    }
365}
366
367#[allow(unused)]
368impl<'ser, W: Write> serde::ser::SerializeStructVariant for &'ser mut Serializer<W> {
369    type Ok = ();
370
371    type Error = Error;
372
373    fn serialize_field<T: ?Sized>(
374        &mut self,
375        key: &'static str,
376        value: &T,
377    ) -> Result<(), Self::Error>
378    where
379        T: serde::Serialize,
380    {
381        Err(unsupport_type!("StructVariant"))
382    }
383
384    fn end(self) -> Result<Self::Ok, Self::Error> {
385        Err(unsupport_type!("StructVariant"))
386    }
387}
minio_rsc/xml/ser.rs

minio_rsc/xml/
ser.rs
