serde_xml_rs/ser/
plain.rs

Help
1use std::io::Write;
2
3use serde::ser::{Impossible, Serialize};
4
5use crate::error::{Error, Result};
6
7pub fn to_plain_string<T>(value: &T) -> Result<String>
8where
9    T: ?Sized + Serialize,
10{
11    let mut writer = Vec::with_capacity(128);
12    value.serialize(&mut PlainStringSerializer::new(&mut writer))?;
13
14    let string = String::from_utf8(writer)?;
15    Ok(string)
16}
17
18struct PlainStringSerializer<W: Write> {
19    writer: W,
20}
21
22impl<W: Write> PlainStringSerializer<W> {
23    fn new(writer: W) -> Self {
24        PlainStringSerializer { writer }
25    }
26
27    fn characters(&mut self, s: &str) -> Result<()> {
28        write!(self.writer, "{}", s)?;
29        Ok(())
30    }
31}
32
33impl<'ser, W: 'ser + Write> serde::ser::Serializer for &'ser mut PlainStringSerializer<W> {
34    type Ok = ();
35    type Error = Error;
36
37    type SerializeSeq = Impossible<Self::Ok, Self::Error>;
38    type SerializeTuple = Impossible<Self::Ok, Self::Error>;
39    type SerializeTupleStruct = Impossible<Self::Ok, Self::Error>;
40    type SerializeTupleVariant = Impossible<Self::Ok, Self::Error>;
41    type SerializeMap = Impossible<Self::Ok, Self::Error>;
42    type SerializeStruct = Impossible<Self::Ok, Self::Error>;
43    type SerializeStructVariant = Impossible<Self::Ok, Self::Error>;
44
45    fn serialize_bool(self, v: bool) -> Result<Self::Ok> {
46        self.characters(&v.to_string())
47    }
48
49    fn serialize_i8(self, v: i8) -> Result<Self::Ok> {
50        self.serialize_i64(i64::from(v))
51    }
52
53    fn serialize_i16(self, v: i16) -> Result<Self::Ok> {
54        self.serialize_i64(i64::from(v))
55    }
56
57    fn serialize_i32(self, v: i32) -> Result<Self::Ok> {
58        self.serialize_i64(i64::from(v))
59    }
60
61    fn serialize_i64(self, v: i64) -> Result<Self::Ok> {
62        self.characters(&v.to_string())
63    }
64
65    fn serialize_u8(self, v: u8) -> Result<Self::Ok> {
66        self.serialize_u64(u64::from(v))
67    }
68
69    fn serialize_u16(self, v: u16) -> Result<Self::Ok> {
70        self.serialize_u64(u64::from(v))
71    }
72
73    fn serialize_u32(self, v: u32) -> Result<Self::Ok> {
74        self.serialize_u64(u64::from(v))
75    }
76
77    fn serialize_u64(self, v: u64) -> Result<Self::Ok> {
78        self.characters(&v.to_string())
79    }
80
81    fn serialize_f32(self, v: f32) -> Result<Self::Ok> {
82        self.serialize_f64(f64::from(v))
83    }
84
85    fn serialize_f64(self, v: f64) -> Result<Self::Ok> {
86        self.characters(&v.to_string())
87    }
88
89    fn serialize_char(self, v: char) -> Result<Self::Ok> {
90        self.characters(&v.to_string())
91    }
92
93    fn serialize_str(self, v: &str) -> Result<Self::Ok> {
94        self.characters(v)
95    }
96
97    fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok> {
98        unimplemented!()
99    }
100
101    fn serialize_none(self) -> Result<Self::Ok> {
102        unimplemented!()
103    }
104
105    fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok>
106    where
107        T: Serialize,
108    {
109        unimplemented!()
110    }
111
112    fn serialize_unit(self) -> Result<Self::Ok> {
113        unimplemented!()
114    }
115
116    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok> {
117        unimplemented!()
118    }
119
120    fn serialize_unit_variant(
121        self,
122        _name: &'static str,
123        _variant_index: u32,
124        _variant: &'static str,
125    ) -> Result<Self::Ok> {
126        unimplemented!()
127    }
128
129    fn serialize_newtype_struct<T: ?Sized>(
130        self,
131        _name: &'static str,
132        _value: &T,
133    ) -> Result<Self::Ok>
134    where
135        T: Serialize,
136    {
137        unimplemented!()
138    }
139
140    fn serialize_newtype_variant<T: ?Sized>(
141        self,
142        _name: &'static str,
143        _variant_index: u32,
144        _variant: &'static str,
145        _value: &T,
146    ) -> Result<Self::Ok>
147    where
148        T: Serialize,
149    {
150        unimplemented!()
151    }
152
153    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
154        unimplemented!()
155    }
156
157    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
158        unimplemented!()
159    }
160
161    fn serialize_tuple_struct(
162        self,
163        _name: &'static str,
164        _len: usize,
165    ) -> Result<Self::SerializeTupleStruct> {
166        unimplemented!()
167    }
168
169    fn serialize_tuple_variant(
170        self,
171        _name: &'static str,
172        _variant_index: u32,
173        _variant: &'static str,
174        _len: usize,
175    ) -> Result<Self::SerializeTupleVariant> {
176        unimplemented!()
177    }
178
179    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
180        unimplemented!()
181    }
182
183    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
184        unimplemented!()
185    }
186
187    fn serialize_struct_variant(
188        self,
189        _name: &'static str,
190        _variant_index: u32,
191        _variant: &'static str,
192        _len: usize,
193    ) -> Result<Self::SerializeStructVariant> {
194        unimplemented!()
195    }
196}
serde_xml_rs/ser/plain.rs

serde_xml_rs/ser/
plain.rs
