1use serde::ser::{
2 Error, Impossible, Serialize, SerializeMap, SerializeStruct, SerializeStructVariant, Serializer,
3};
4
5pub(crate) struct NodeSerializer<'a, M> {
6 map: &'a mut M,
7}
8
9impl<'a, M> NodeSerializer<'a, M> {
10 pub(crate) fn new(map: &'a mut M) -> Self {
11 NodeSerializer { map }
12 }
13}
14
15impl<'a, M> Serializer for NodeSerializer<'a, M>
16where
17 M: SerializeMap,
18{
19 type Ok = ();
20 type Error = M::Error;
21 type SerializeSeq = Impossible<Self::Ok, Self::Error>;
22 type SerializeTuple = Impossible<Self::Ok, Self::Error>;
23 type SerializeTupleStruct = Impossible<Self::Ok, Self::Error>;
24 type SerializeTupleVariant = Impossible<Self::Ok, Self::Error>;
25 type SerializeMap = Self;
26 type SerializeStruct = Self;
27 type SerializeStructVariant = Self;
28
29 fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
30 let _ = v;
31 Err(Error::custom("unsupported \"kind\""))
32 }
33
34 fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
35 let _ = v;
36 Err(Error::custom("unsupported \"kind\""))
37 }
38
39 fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
40 let _ = v;
41 Err(Error::custom("unsupported \"kind\""))
42 }
43
44 fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
45 let _ = v;
46 Err(Error::custom("unsupported \"kind\""))
47 }
48
49 fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
50 let _ = v;
51 Err(Error::custom("unsupported \"kind\""))
52 }
53
54 fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
55 let _ = v;
56 Err(Error::custom("unsupported \"kind\""))
57 }
58
59 fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
60 let _ = v;
61 Err(Error::custom("unsupported \"kind\""))
62 }
63
64 fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
65 let _ = v;
66 Err(Error::custom("unsupported \"kind\""))
67 }
68
69 fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
70 let _ = v;
71 Err(Error::custom("unsupported \"kind\""))
72 }
73
74 fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
75 let _ = v;
76 Err(Error::custom("unsupported \"kind\""))
77 }
78
79 fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
80 let _ = v;
81 Err(Error::custom("unsupported \"kind\""))
82 }
83
84 fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
85 let _ = v;
86 Err(Error::custom("unsupported \"kind\""))
87 }
88
89 fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
90 let _ = v;
91 Err(Error::custom("unsupported \"kind\""))
92 }
93
94 fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
95 let _ = v;
96 Err(Error::custom("unsupported \"kind\""))
97 }
98
99 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
100 Ok(())
101 }
102
103 fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
104 where
105 T: ?Sized + Serialize,
106 {
107 T::serialize(value, self)
108 }
109
110 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
111 Ok(())
112 }
113
114 fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
115 let _ = name;
116 Ok(())
117 }
118
119 fn serialize_unit_variant(
120 self,
121 name: &'static str,
122 variant_index: u32,
123 variant: &'static str,
124 ) -> Result<Self::Ok, Self::Error> {
125 let _ = name;
126 let _ = variant_index;
127 self.map.serialize_entry("kind", variant)
128 }
129
130 fn serialize_newtype_struct<T>(
131 self,
132 name: &'static str,
133 value: &T,
134 ) -> Result<Self::Ok, Self::Error>
135 where
136 T: ?Sized + Serialize,
137 {
138 let _ = name;
139 T::serialize(value, self)
140 }
141
142 fn serialize_newtype_variant<T>(
143 self,
144 name: &'static str,
145 variant_index: u32,
146 variant: &'static str,
147 value: &T,
148 ) -> Result<Self::Ok, Self::Error>
149 where
150 T: ?Sized + Serialize,
151 {
152 let _ = name;
153 let _ = variant_index;
154 self.map.serialize_entry("kind", variant)?;
155 T::serialize(value, self)
156 }
157
158 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
159 let _ = len;
160 Err(Error::custom("unsupported \"kind\""))
161 }
162
163 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
164 let _ = len;
165 Err(Error::custom("unsupported \"kind\""))
166 }
167
168 fn serialize_tuple_struct(
169 self,
170 name: &'static str,
171 len: usize,
172 ) -> Result<Self::SerializeTupleStruct, Self::Error> {
173 let _ = name;
174 let _ = len;
175 Err(Error::custom("unsupported \"kind\""))
176 }
177
178 fn serialize_tuple_variant(
179 self,
180 name: &'static str,
181 variant_index: u32,
182 variant: &'static str,
183 len: usize,
184 ) -> Result<Self::SerializeTupleVariant, Self::Error> {
185 let _ = name;
186 let _ = variant_index;
187 let _ = variant;
188 let _ = len;
189 Err(Error::custom("unsupported \"kind\""))
190 }
191
192 fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
193 let _ = len;
194 Ok(self)
195 }
196
197 fn serialize_struct(
198 self,
199 name: &'static str,
200 len: usize,
201 ) -> Result<Self::SerializeStruct, Self::Error> {
202 let _ = name;
203 let _ = len;
204 Ok(self)
205 }
206
207 fn serialize_struct_variant(
208 self,
209 name: &'static str,
210 variant_index: u32,
211 variant: &'static str,
212 len: usize,
213 ) -> Result<Self::SerializeStructVariant, Self::Error> {
214 let _ = name;
215 let _ = variant_index;
216 let _ = len;
217 self.map.serialize_entry("kind", variant)?;
218 Ok(self)
219 }
220}
221
222impl<'a, M> SerializeMap for NodeSerializer<'a, M>
223where
224 M: SerializeMap,
225{
226 type Ok = ();
227 type Error = M::Error;
228
229 fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
230 where
231 T: ?Sized + Serialize,
232 {
233 self.map.serialize_key(key)
234 }
235
236 fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
237 where
238 T: ?Sized + Serialize,
239 {
240 self.map.serialize_value(value)
241 }
242
243 fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), Self::Error>
244 where
245 K: ?Sized + Serialize,
246 V: ?Sized + Serialize,
247 {
248 self.map.serialize_entry(key, value)
249 }
250
251 fn end(self) -> Result<(), Self::Error> {
252 Ok(())
253 }
254}
255
256impl<'a, M> SerializeStruct for NodeSerializer<'a, M>
257where
258 M: SerializeMap,
259{
260 type Ok = ();
261 type Error = M::Error;
262
263 fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
264 where
265 T: ?Sized + Serialize,
266 {
267 self.map.serialize_entry(key, value)
268 }
269
270 fn end(self) -> Result<(), Self::Error> {
271 Ok(())
272 }
273}
274
275impl<'a, M> SerializeStructVariant for NodeSerializer<'a, M>
276where
277 M: SerializeMap,
278{
279 type Ok = ();
280 type Error = M::Error;
281
282 fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
283 where
284 T: ?Sized + Serialize,
285 {
286 self.map.serialize_entry(key, value)
287 }
288
289 fn end(self) -> Result<(), Self::Error> {
290 Ok(())
291 }
292}