1use std::str;
2
3use serde::ser::{self, Serializer as _};
4
5use super::Error;
6
7pub struct PartSerializer<S> {
8 sink: S,
9}
10
11impl<S: Sink> PartSerializer<S> {
12 pub fn new(sink: S) -> Self {
13 PartSerializer { sink }
14 }
15}
16
17pub trait Sink: Sized {
18 type Ok;
19 type SerializeSeq: ser::SerializeSeq<Ok = Self::Ok, Error = Error>;
20
21 fn serialize_static_str(self, value: &'static str) -> Result<Self::Ok, Error>;
22
23 fn serialize_str(self, value: &str) -> Result<Self::Ok, Error>;
24 fn serialize_string(self, value: String) -> Result<Self::Ok, Error>;
25 fn serialize_none(self) -> Result<Self::Ok, Error>;
26
27 fn serialize_some<T: ?Sized + ser::Serialize>(self, value: &T) -> Result<Self::Ok, Error>;
28
29 fn serialize_seq(self) -> Result<Self::SerializeSeq, Error>;
30
31 fn unsupported(self) -> Error;
32}
33
34impl<S: Sink> ser::Serializer for PartSerializer<S> {
35 type Ok = S::Ok;
36 type Error = Error;
37 type SerializeSeq = S::SerializeSeq;
38 type SerializeTuple = ser::Impossible<S::Ok, Error>;
39 type SerializeTupleStruct = ser::Impossible<S::Ok, Error>;
40 type SerializeTupleVariant = ser::Impossible<S::Ok, Error>;
41 type SerializeMap = ser::Impossible<S::Ok, Error>;
42 type SerializeStruct = ser::Impossible<S::Ok, Error>;
43 type SerializeStructVariant = ser::Impossible<S::Ok, Error>;
44
45 fn serialize_bool(self, v: bool) -> Result<S::Ok, Error> {
46 self.sink.serialize_static_str(if v { "true" } else { "false" })
47 }
48
49 fn serialize_i8(self, v: i8) -> Result<S::Ok, Error> {
50 self.serialize_integer(v)
51 }
52
53 fn serialize_i16(self, v: i16) -> Result<S::Ok, Error> {
54 self.serialize_integer(v)
55 }
56
57 fn serialize_i32(self, v: i32) -> Result<S::Ok, Error> {
58 self.serialize_integer(v)
59 }
60
61 fn serialize_i64(self, v: i64) -> Result<S::Ok, Error> {
62 self.serialize_integer(v)
63 }
64
65 fn serialize_u8(self, v: u8) -> Result<S::Ok, Error> {
66 self.serialize_integer(v)
67 }
68
69 fn serialize_u16(self, v: u16) -> Result<S::Ok, Error> {
70 self.serialize_integer(v)
71 }
72
73 fn serialize_u32(self, v: u32) -> Result<S::Ok, Error> {
74 self.serialize_integer(v)
75 }
76
77 fn serialize_u64(self, v: u64) -> Result<S::Ok, Error> {
78 self.serialize_integer(v)
79 }
80
81 fn serialize_u128(self, v: u128) -> Result<S::Ok, Error> {
82 self.serialize_integer(v)
83 }
84
85 fn serialize_i128(self, v: i128) -> Result<S::Ok, Error> {
86 self.serialize_integer(v)
87 }
88
89 fn serialize_f32(self, v: f32) -> Result<S::Ok, Error> {
90 #[cfg(feature = "ryu")]
91 return self.serialize_floating(v);
92
93 #[cfg(not(feature = "ryu"))]
94 return self.serialize_str(&v.to_string());
95 }
96
97 fn serialize_f64(self, v: f64) -> Result<S::Ok, Error> {
98 #[cfg(feature = "ryu")]
99 return self.serialize_floating(v);
100
101 #[cfg(not(feature = "ryu"))]
102 return self.serialize_str(&v.to_string());
103 }
104
105 fn serialize_char(self, v: char) -> Result<S::Ok, Error> {
106 self.sink.serialize_string(v.to_string())
107 }
108
109 fn serialize_str(self, value: &str) -> Result<S::Ok, Error> {
110 self.sink.serialize_str(value)
111 }
112
113 fn serialize_bytes(self, value: &[u8]) -> Result<S::Ok, Error> {
114 match str::from_utf8(value) {
115 Ok(value) => self.sink.serialize_str(value),
116 Err(err) => Err(Error::utf8(err)),
117 }
118 }
119
120 fn serialize_unit(self) -> Result<S::Ok, Error> {
121 Err(self.sink.unsupported())
122 }
123
124 fn serialize_unit_struct(self, name: &'static str) -> Result<S::Ok, Error> {
125 self.sink.serialize_static_str(name)
126 }
127
128 fn serialize_unit_variant(
129 self,
130 _name: &'static str,
131 _variant_index: u32,
132 variant: &'static str,
133 ) -> Result<S::Ok, Error> {
134 self.sink.serialize_static_str(variant)
135 }
136
137 fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
138 self,
139 _name: &'static str,
140 value: &T,
141 ) -> Result<S::Ok, Error> {
142 value.serialize(self)
143 }
144
145 fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
146 self,
147 _name: &'static str,
148 _variant_index: u32,
149 _variant: &'static str,
150 _value: &T,
151 ) -> Result<S::Ok, Error> {
152 Err(self.sink.unsupported())
153 }
154
155 fn serialize_none(self) -> Result<S::Ok, Error> {
156 self.sink.serialize_none()
157 }
158
159 fn serialize_some<T: ?Sized + ser::Serialize>(self, value: &T) -> Result<S::Ok, Error> {
160 self.sink.serialize_some(value)
161 }
162
163 fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Error> {
164 self.sink.serialize_seq()
165 }
166
167 fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Error> {
168 Err(self.sink.unsupported())
169 }
170
171 fn serialize_tuple_struct(
172 self,
173 _name: &'static str,
174 _len: usize,
175 ) -> Result<Self::SerializeTuple, Error> {
176 Err(self.sink.unsupported())
177 }
178
179 fn serialize_tuple_variant(
180 self,
181 _name: &'static str,
182 _variant_index: u32,
183 _variant: &'static str,
184 _len: usize,
185 ) -> Result<Self::SerializeTupleVariant, Error> {
186 Err(self.sink.unsupported())
187 }
188
189 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Error> {
190 Err(self.sink.unsupported())
191 }
192
193 fn serialize_struct(
194 self,
195 _name: &'static str,
196 _len: usize,
197 ) -> Result<Self::SerializeStruct, Error> {
198 Err(self.sink.unsupported())
199 }
200
201 fn serialize_struct_variant(
202 self,
203 _name: &'static str,
204 _variant_index: u32,
205 _variant: &'static str,
206 _len: usize,
207 ) -> Result<Self::SerializeStructVariant, Error> {
208 Err(self.sink.unsupported())
209 }
210}
211
212impl<S: Sink> PartSerializer<S> {
213 fn serialize_integer<I>(self, value: I) -> Result<S::Ok, Error>
214 where
215 I: itoa::Integer,
216 {
217 let mut buf = itoa::Buffer::new();
218 self.serialize_str(buf.format(value))
219 }
220
221 #[cfg(feature = "ryu")]
222 fn serialize_floating<F>(self, value: F) -> Result<S::Ok, Error>
223 where
224 F: ryu::Float,
225 {
226 let mut buf = ryu::Buffer::new();
227 self.serialize_str(buf.format(value))
228 }
229}