1use serde::ser::{self, Serialize};
2
3use crate::error::{Error, Result};
4use crate::internal::{InternalPrompt, ScopeLimit};
5use crate::internal_prompt_responder_mixin;
6use crate::prompt::{PromptResponder, RequestKind};
7
8pub struct Serializer<P: PromptResponder> {
9 prompt: InternalPrompt<P>,
10}
11
12impl<P: PromptResponder> Serializer<P> {
13 pub fn from_prompt(prompt: P) -> Self {
14 Serializer {
15 prompt: InternalPrompt::from_prompt(prompt),
16 }
17 }
18
19 pub fn cleanup(&mut self) -> Result<()> {
20 self.prompt.cleanup()
21 }
22
23 internal_prompt_responder_mixin!(prompt);
24}
25
26macro_rules! serialize_to_str {
27 ($tname:ident, $dmethod:ident) => {
28 fn $dmethod(self, v: $tname) -> Result<()> {
29 self.respond(RequestKind::Datum, stringify!($tname), &v.to_string())?;
30 self.end_implicit_scopes()
31 }
32 };
33}
34
35impl<'a, P: PromptResponder> ser::Serializer for &'a mut Serializer<P> {
36 type Ok = ();
37 type Error = Error;
38
39 type SerializeSeq = Seq<'a, P>;
40 type SerializeTuple = Tuple<'a, P>;
41 type SerializeTupleStruct = Tuple<'a, P>;
42 type SerializeTupleVariant = Tuple<'a, P>;
43 type SerializeMap = Map<'a, P>;
44 type SerializeStruct = Self;
45 type SerializeStructVariant = Self;
46
47 serialize_to_str!(bool, serialize_bool);
48 serialize_to_str!(u8, serialize_u8);
49 serialize_to_str!(u16, serialize_u16);
50 serialize_to_str!(u32, serialize_u32);
51 serialize_to_str!(u64, serialize_u64);
52 serialize_to_str!(u128, serialize_u128);
53 serialize_to_str!(i8, serialize_i8);
54 serialize_to_str!(i16, serialize_i16);
55 serialize_to_str!(i32, serialize_i32);
56 serialize_to_str!(i64, serialize_i64);
57 serialize_to_str!(i128, serialize_i128);
58 serialize_to_str!(f32, serialize_f32);
59 serialize_to_str!(f64, serialize_f64);
60 serialize_to_str!(char, serialize_char);
61
62 fn serialize_str(self, v: &str) -> Result<()> {
63 self.respond(RequestKind::Datum, "string", v)?;
64 self.end_implicit_scopes()
65 }
66
67 fn serialize_bytes(self, v: &[u8]) -> Result<()> {
68 self.begin_scope("bytes", None, ScopeLimit::Explicit)?;
69 for byte in v {
70 self.respond(RequestKind::Question, "Add byte?", "yes")?;
71 self.respond(RequestKind::Datum, "u8", &byte.to_string())?;
72 }
73 self.respond(RequestKind::Question, "Add byte?", "no")?;
74 self.end_scope()
75 }
76
77 fn serialize_none(self) -> Result<()> {
78 self.begin_scope("option", None, ScopeLimit::Explicit)?;
79 self.respond(RequestKind::Question, "Some value?", "no")?;
80 self.end_scope()
81 }
82
83 fn serialize_some<T>(self, value: &T) -> Result<()>
84 where
85 T: ?Sized + Serialize,
86 {
87 self.begin_scope("option", None, ScopeLimit::Implicit)?;
88 self.respond(RequestKind::Question, "Some value?", "yes")?;
89 value.serialize(self)
90 }
91
92 fn serialize_unit(self) -> Result<()> {
93 self.respond(RequestKind::Synthetic, "unit", "()")?;
94 self.end_implicit_scopes()
95 }
96
97 fn serialize_unit_struct(self, name: &'static str) -> Result<()> {
98 self.begin_scope(name, Some(1), ScopeLimit::Explicit)?;
99 self.respond(RequestKind::Synthetic, "unit", "()")?;
100 self.end_scope()
101 }
102
103 fn serialize_unit_variant(
104 self,
105 name: &'static str,
106 _variant_index: u32,
107 variant: &'static str,
108 ) -> Result<()> {
109 self.begin_scope(name, None, ScopeLimit::Explicit)?;
110 self.respond(RequestKind::Datum, "variant", variant)?;
111 self.end_scope()
112 }
113
114 fn serialize_newtype_struct<T>(
115 self,
116 name: &'static str,
117 value: &T,
118 ) -> Result<()>
119 where
120 T: ?Sized + Serialize,
121 {
122 self.begin_scope(name, Some(1), ScopeLimit::Implicit)?;
123 value.serialize(self)
124 }
125
126 fn serialize_newtype_variant<T>(
127 self,
128 name: &'static str,
129 _variant_index: u32,
130 variant: &'static str,
131 value: &T,
132 ) -> Result<()>
133 where
134 T: ?Sized + Serialize,
135 {
136 self.begin_scope(name, Some(1), ScopeLimit::Implicit)?;
137 self.respond(RequestKind::Datum, "variant", variant)?;
138 value.serialize(self)
139 }
140
141 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
142 self.begin_scope("seq", len.map(|x| x + 1), ScopeLimit::Explicit)?;
143 Ok(Seq::new(self))
144 }
145
146 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
147 self.begin_scope("tuple", Some(len), ScopeLimit::Explicit)?;
148 Ok(Tuple::new(self, len))
149 }
150
151 fn serialize_tuple_struct(
152 self,
153 name: &'static str,
154 len: usize,
155 ) -> Result<Self::SerializeTupleStruct> {
156 self.begin_scope(name, Some(len), ScopeLimit::Explicit)?;
157 Ok(Tuple::new(self, len))
158 }
159
160 fn serialize_tuple_variant(
161 self,
162 name: &'static str,
163 _variant_index: u32,
164 variant: &'static str,
165 len: usize,
166 ) -> Result<Self::SerializeTupleVariant> {
167 self.begin_scope(name, None, ScopeLimit::Explicit)?;
168 self.respond(RequestKind::Datum, "variant", variant)?;
169 self.begin_scope(variant, Some(len), ScopeLimit::Explicit)?;
170 Ok(Tuple::new(self, len))
171 }
172
173 fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
174 self.begin_scope("map", len.map(|x| x + 1), ScopeLimit::Explicit)?;
175 Ok(Map::new(self))
176 }
177
178 fn serialize_struct(
179 self,
180 name: &'static str,
181 len: usize,
182 ) -> Result<Self::SerializeStruct> {
183 self.begin_scope(name, Some(len), ScopeLimit::Explicit)?;
184 Ok(self)
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 self.begin_scope(name, None, ScopeLimit::Explicit)?;
195 self.respond(RequestKind::Datum, "variant", variant)?;
196 self.begin_scope(variant, Some(len), ScopeLimit::Explicit)?;
197 Ok(self)
198 }
199}
200
201#[doc(hidden)]
202pub struct Seq<'a, P: PromptResponder> {
203 ser: &'a mut Serializer<P>,
204 index: usize,
205}
206
207impl<'a, P: PromptResponder> Seq<'a, P> {
208 fn new(ser: &'a mut Serializer<P>) -> Self {
209 Seq { ser, index: 0 }
210 }
211}
212
213impl<'a, P: PromptResponder> ser::SerializeSeq for Seq<'a, P> {
214 type Ok = ();
215 type Error = Error;
216
217 fn serialize_element<T>(&mut self, value: &T) -> Result<()>
218 where
219 T: ?Sized + Serialize,
220 {
221 self.ser.begin_scope(
222 &format!("[{}]", self.index),
223 None,
224 ScopeLimit::Explicit,
225 )?;
226 self.index += 1;
227 self
228 .ser
229 .respond(RequestKind::Question, "Add element?", "yes")?;
230 value.serialize(&mut *self.ser)?;
231 self.ser.end_scope()
232 }
233
234 fn end(self) -> Result<()> {
235 self.ser.begin_scope(
236 &format!("[{}]", self.index),
237 None,
238 ScopeLimit::Explicit,
239 )?;
240 self
241 .ser
242 .respond(RequestKind::Question, "Add element?", "no")?;
243 self.ser.end_scope()?;
244 self.ser.end_scope()
245 }
246}
247
248#[doc(hidden)]
249pub struct Tuple<'a, P: PromptResponder> {
250 ser: &'a mut Serializer<P>,
251 index: usize,
252 len: usize,
253}
254
255impl<'a, P: PromptResponder> Tuple<'a, P> {
256 fn new(ser: &'a mut Serializer<P>, len: usize) -> Self {
257 Tuple { ser, index: 0, len }
258 }
259}
260
261impl<'a, P: PromptResponder> ser::SerializeTuple for Tuple<'a, P> {
262 type Ok = ();
263 type Error = Error;
264
265 fn serialize_element<T>(&mut self, value: &T) -> Result<()>
266 where
267 T: ?Sized + Serialize,
268 {
269 self.ser.begin_scope(
270 &format!("[{}/{}]", self.index + 1, self.len),
271 None,
272 ScopeLimit::Explicit,
273 )?;
274 self.index += 1;
275 value.serialize(&mut *self.ser)?;
276 self.ser.end_scope()
277 }
278
279 fn end(self) -> Result<()> {
280 self.ser.end_scope()
281 }
282}
283
284impl<'a, P: PromptResponder> ser::SerializeTupleStruct for Tuple<'a, P> {
285 type Ok = ();
286 type Error = Error;
287
288 fn serialize_field<T>(&mut self, value: &T) -> Result<()>
289 where
290 T: ?Sized + Serialize,
291 {
292 use serde::ser::SerializeTuple;
293 self.serialize_element(value)
294 }
295
296 fn end(self) -> Result<()> {
297 self.ser.end_scope()
298 }
299}
300
301impl<'a, P: PromptResponder> ser::SerializeTupleVariant for Tuple<'a, P> {
302 type Ok = ();
303 type Error = Error;
304
305 fn serialize_field<T>(&mut self, value: &T) -> Result<()>
306 where
307 T: ?Sized + Serialize,
308 {
309 use serde::ser::SerializeTuple;
310 self.serialize_element(value)
311 }
312
313 fn end(self) -> Result<()> {
314 self.ser.end_scope()?;
315 self.ser.end_scope()
316 }
317}
318
319#[doc(hidden)]
320pub struct Map<'a, P: PromptResponder> {
321 ser: &'a mut Serializer<P>,
322 index: usize,
323}
324
325impl<'a, P: PromptResponder> Map<'a, P> {
326 fn new(ser: &'a mut Serializer<P>) -> Self {
327 Map { ser, index: 0 }
328 }
329}
330
331impl<'a, P: PromptResponder> ser::SerializeMap for Map<'a, P> {
332 type Ok = ();
333 type Error = Error;
334
335 fn serialize_key<T>(&mut self, key: &T) -> Result<()>
336 where
337 T: ?Sized + Serialize,
338 {
339 self.ser.begin_scope(
340 &format!("[{}]", self.index),
341 None,
342 ScopeLimit::Explicit,
343 )?;
344 self.index += 1;
345 self
346 .ser
347 .prompt
348 .respond(RequestKind::Question, "Add entry?", "yes")?;
349 key.serialize(&mut *self.ser)
350 }
351
352 fn serialize_value<T>(&mut self, value: &T) -> Result<()>
353 where
354 T: ?Sized + Serialize,
355 {
356 value.serialize(&mut *self.ser)?;
357 self.ser.end_scope()
358 }
359
360 fn end(self) -> Result<()> {
361 self.ser.begin_scope(
362 &format!("[{}]", self.index),
363 None,
364 ScopeLimit::Explicit,
365 )?;
366 self
367 .ser
368 .respond(RequestKind::Question, "Add entry?", "no")?;
369 self.ser.end_scope()?;
370 self.ser.end_scope()
371 }
372}
373
374impl<'a, P: PromptResponder> ser::SerializeStruct for &'a mut Serializer<P> {
375 type Ok = ();
376 type Error = Error;
377
378 fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
379 where
380 T: ?Sized + Serialize,
381 {
382 self.begin_scope(key, Some(1), ScopeLimit::Explicit)?;
383 value.serialize(&mut **self)?;
384 self.end_scope()
385 }
386
387 fn end(self) -> Result<()> {
388 self.end_scope()
389 }
390}
391
392impl<'a, P: PromptResponder> ser::SerializeStructVariant
393 for &'a mut Serializer<P>
394{
395 type Ok = ();
396 type Error = Error;
397
398 fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
399 where
400 T: ?Sized + Serialize,
401 {
402 self.begin_scope(key, Some(1), ScopeLimit::Explicit)?;
403 value.serialize(&mut **self)?;
404 self.end_scope()
405 }
406
407 fn end(self) -> Result<()> {
408 self.end_scope()?;
409 self.end_scope()
410 }
411}