1use std::{borrow::Cow, fmt::Display, io::Write};
2
3use percent_encoding::{percent_encode, AsciiSet, NON_ALPHANUMERIC};
4use serde::{
5 ser::{Impossible, SerializeMap, SerializeSeq, SerializeStruct, SerializeTuple},
6 Serialize, Serializer,
7};
8
9const QS_ENCODE_SET: &AsciiSet = &NON_ALPHANUMERIC
10 .remove(b' ')
11 .remove(b'*')
12 .remove(b'-')
13 .remove(b'.')
14 .remove(b'_');
15
16#[derive(Debug, thiserror::Error)]
18pub enum QsError {
19 #[error("{0}")]
21 Custom(String),
22
23 #[error("unsupported type for serialization")]
25 Unsupported,
26
27 #[error(transparent)]
29 Io(#[from] std::io::Error),
30}
31
32impl serde::ser::Error for QsError {
33 #[inline]
34 fn custom<T: Display>(msg: T) -> Self {
35 QsError::Custom(msg.to_string())
36 }
37}
38
39fn replace_space(input: &str) -> Cow<str> {
40 match input.as_bytes().iter().position(|&b| b == b' ') {
41 None => Cow::Borrowed(input),
42 Some(first_position) => {
43 let mut replaced = input.as_bytes().to_owned();
44 replaced[first_position] = b'+';
45 for byte in &mut replaced[first_position + 1..] {
46 if *byte == b' ' {
47 *byte = b'+';
48 }
49 }
50 Cow::Owned(String::from_utf8(replaced).expect("replacing ' ' with '+' cannot panic"))
51 }
52 }
53}
54
55macro_rules! unsupported_types {
56 ($(($ty:ty, $meth:ident)),*) => {
57 $(
58 fn $meth(self, _: $ty) -> Result<Self::Ok, Self::Error> {
59 Err(QsError::Unsupported)
60 }
61 )*
62 };
63}
64
65macro_rules! serialize_value_to_string {
66 ($(($ty:ty, $meth:ident)),*) => {
67 $(
68 fn $meth(self, v: $ty) -> Result<Self::Ok, Self::Error> {
69 Ok(vec![v.to_string()])
70 }
71 )*
72 };
73}
74
75macro_rules! serialize_primary_value_to_string {
76 ($(($ty:ty, $meth:ident)),*) => {
77 $(
78 fn $meth(self, v: $ty) -> Result<Self::Ok, Self::Error> {
79 Ok(Some(v.to_string()))
80 }
81 )*
82 };
83}
84
85macro_rules! serialize_key_to_string {
86 ($(($ty:ty, $meth:ident)),*) => {
87 $(
88 fn $meth(self, v: $ty) -> Result<Self::Ok, Self::Error> {
89 Ok(v.to_string())
90 }
91 )*
92 };
93}
94
95struct ValueWriter<'a, W> {
96 writer: &'a mut W,
97 first: bool,
98}
99
100impl<'a, W: Write> ValueWriter<'a, W> {
101 fn add_pair(&mut self, key: &str, value: &str) -> Result<(), QsError> {
102 write!(
103 self.writer,
104 "{}{}={}",
105 if self.first {
106 self.first = false;
107 ""
108 } else {
109 "&"
110 },
111 key,
112 percent_encode(value.as_bytes(), QS_ENCODE_SET)
113 .map(replace_space)
114 .collect::<String>()
115 )?;
116 Ok(())
117 }
118}
119
120struct QsSerializer<'a, 'b, W> {
121 writer: &'a mut ValueWriter<'b, W>,
122}
123
124impl<'a, 'b, W: Write> Serializer for QsSerializer<'a, 'b, W> {
125 type Ok = ();
126 type Error = QsError;
127 type SerializeSeq = QsSeqSerializer<'a, 'b, W>;
128 type SerializeTuple = QsTupleSerializer<'a, 'b, W>;
129 type SerializeTupleStruct = Impossible<(), QsError>;
130 type SerializeTupleVariant = Impossible<(), QsError>;
131 type SerializeMap = QsMapSerializer<'a, 'b, W>;
132 type SerializeStruct = QsStructSerializer<'a, 'b, W>;
133 type SerializeStructVariant = Impossible<(), QsError>;
134
135 unsupported_types!(
136 (bool, serialize_bool),
137 (u8, serialize_u8),
138 (u16, serialize_u16),
139 (u32, serialize_u32),
140 (u64, serialize_u64),
141 (i8, serialize_i8),
142 (i16, serialize_i16),
143 (i32, serialize_i32),
144 (i64, serialize_i64),
145 (f32, serialize_f32),
146 (f64, serialize_f64),
147 (char, serialize_char),
148 (&str, serialize_str),
149 (&[u8], serialize_bytes)
150 );
151
152 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
153 Err(QsError::Unsupported)
154 }
155
156 fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
157 where
158 T: serde::Serialize,
159 {
160 Err(QsError::Unsupported)
161 }
162
163 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
164 Err(QsError::Unsupported)
165 }
166
167 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
168 Err(QsError::Unsupported)
169 }
170
171 fn serialize_unit_variant(
172 self,
173 _name: &'static str,
174 _variant_index: u32,
175 _variant: &'static str,
176 ) -> Result<Self::Ok, Self::Error> {
177 Err(QsError::Unsupported)
178 }
179
180 fn serialize_newtype_struct<T: ?Sized>(
181 self,
182 _name: &'static str,
183 _value: &T,
184 ) -> Result<Self::Ok, Self::Error>
185 where
186 T: serde::Serialize,
187 {
188 Err(QsError::Unsupported)
189 }
190
191 fn serialize_newtype_variant<T: ?Sized>(
192 self,
193 _name: &'static str,
194 _variant_index: u32,
195 _variant: &'static str,
196 _value: &T,
197 ) -> Result<Self::Ok, Self::Error>
198 where
199 T: serde::Serialize,
200 {
201 Err(QsError::Unsupported)
202 }
203
204 fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
205 Ok(QsSeqSerializer {
206 writer: self.writer,
207 })
208 }
209
210 fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
211 Ok(QsTupleSerializer {
212 writer: self.writer,
213 })
214 }
215
216 fn serialize_tuple_struct(
217 self,
218 _name: &'static str,
219 _len: usize,
220 ) -> Result<Self::SerializeTupleStruct, Self::Error> {
221 Err(QsError::Unsupported)
222 }
223
224 fn serialize_tuple_variant(
225 self,
226 _name: &'static str,
227 _variant_index: u32,
228 _variant: &'static str,
229 _len: usize,
230 ) -> Result<Self::SerializeTupleVariant, Self::Error> {
231 Err(QsError::Unsupported)
232 }
233
234 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
235 Ok(QsMapSerializer {
236 writer: self.writer,
237 key: None,
238 })
239 }
240
241 fn serialize_struct(
242 self,
243 _name: &'static str,
244 _len: usize,
245 ) -> Result<Self::SerializeStruct, Self::Error> {
246 Ok(QsStructSerializer {
247 writer: self.writer,
248 })
249 }
250
251 fn serialize_struct_variant(
252 self,
253 _name: &'static str,
254 _variant_index: u32,
255 _variant: &'static str,
256 _len: usize,
257 ) -> Result<Self::SerializeStructVariant, Self::Error> {
258 Err(QsError::Unsupported)
259 }
260}
261
262struct QsSeqSerializer<'a, 'b, W> {
263 writer: &'a mut ValueWriter<'b, W>,
264}
265
266impl<'a, 'b, W: Write> SerializeSeq for QsSeqSerializer<'a, 'b, W> {
267 type Ok = ();
268 type Error = QsError;
269
270 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
271 where
272 T: Serialize,
273 {
274 value.serialize(QsSeqItemSerializer {
275 writer: self.writer,
276 })
277 }
278
279 fn end(self) -> Result<Self::Ok, Self::Error> {
280 Ok(())
281 }
282}
283
284struct QsTupleSerializer<'a, 'b, W> {
285 writer: &'a mut ValueWriter<'b, W>,
286}
287
288impl<'a, 'b, W: Write> SerializeTuple for QsTupleSerializer<'a, 'b, W> {
289 type Ok = ();
290 type Error = QsError;
291
292 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
293 where
294 T: Serialize,
295 {
296 value.serialize(QsSeqItemSerializer {
297 writer: self.writer,
298 })
299 }
300
301 fn end(self) -> Result<Self::Ok, Self::Error> {
302 Ok(())
303 }
304}
305
306struct QsSeqItemSerializer<'a, 'b, W> {
307 writer: &'a mut ValueWriter<'b, W>,
308}
309
310impl<'a, 'b, W: Write> Serializer for QsSeqItemSerializer<'a, 'b, W> {
311 type Ok = ();
312 type Error = QsError;
313
314 type SerializeSeq = Impossible<(), QsError>;
315 type SerializeTuple = QsTuplePairSerializer<'a, 'b, W>;
316 type SerializeTupleStruct = Impossible<(), QsError>;
317 type SerializeTupleVariant = Impossible<(), QsError>;
318 type SerializeMap = Impossible<(), QsError>;
319 type SerializeStruct = Impossible<(), QsError>;
320 type SerializeStructVariant = Impossible<(), QsError>;
321
322 unsupported_types!(
323 (bool, serialize_bool),
324 (u8, serialize_u8),
325 (u16, serialize_u16),
326 (u32, serialize_u32),
327 (u64, serialize_u64),
328 (i8, serialize_i8),
329 (i16, serialize_i16),
330 (i32, serialize_i32),
331 (i64, serialize_i64),
332 (f32, serialize_f32),
333 (f64, serialize_f64),
334 (char, serialize_char),
335 (&str, serialize_str),
336 (&[u8], serialize_bytes)
337 );
338
339 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
340 Err(QsError::Unsupported)
341 }
342
343 fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
344 where
345 T: Serialize,
346 {
347 Err(QsError::Unsupported)
348 }
349
350 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
351 Err(QsError::Unsupported)
352 }
353
354 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
355 Err(QsError::Unsupported)
356 }
357
358 fn serialize_unit_variant(
359 self,
360 _name: &'static str,
361 _variant_index: u32,
362 _variant: &'static str,
363 ) -> Result<Self::Ok, Self::Error> {
364 Err(QsError::Unsupported)
365 }
366
367 fn serialize_newtype_struct<T: ?Sized>(
368 self,
369 _name: &'static str,
370 _value: &T,
371 ) -> Result<Self::Ok, Self::Error>
372 where
373 T: Serialize,
374 {
375 Err(QsError::Unsupported)
376 }
377
378 fn serialize_newtype_variant<T: ?Sized>(
379 self,
380 _name: &'static str,
381 _variant_index: u32,
382 _variant: &'static str,
383 _value: &T,
384 ) -> Result<Self::Ok, Self::Error>
385 where
386 T: Serialize,
387 {
388 Err(QsError::Unsupported)
389 }
390
391 fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
392 Err(QsError::Unsupported)
393 }
394
395 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
396 if len != 2 {
397 return Err(QsError::Unsupported);
398 }
399 Ok(QsTuplePairSerializer {
400 writer: self.writer,
401 key: None,
402 })
403 }
404
405 fn serialize_tuple_struct(
406 self,
407 _name: &'static str,
408 _len: usize,
409 ) -> Result<Self::SerializeTupleStruct, Self::Error> {
410 Err(QsError::Unsupported)
411 }
412
413 fn serialize_tuple_variant(
414 self,
415 _name: &'static str,
416 _variant_index: u32,
417 _variant: &'static str,
418 _len: usize,
419 ) -> Result<Self::SerializeTupleVariant, Self::Error> {
420 Err(QsError::Unsupported)
421 }
422
423 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
424 Err(QsError::Unsupported)
425 }
426
427 fn serialize_struct(
428 self,
429 _name: &'static str,
430 _len: usize,
431 ) -> Result<Self::SerializeStruct, Self::Error> {
432 Err(QsError::Unsupported)
433 }
434
435 fn serialize_struct_variant(
436 self,
437 _name: &'static str,
438 _variant_index: u32,
439 _variant: &'static str,
440 _len: usize,
441 ) -> Result<Self::SerializeStructVariant, Self::Error> {
442 Err(QsError::Unsupported)
443 }
444}
445
446struct QsTuplePairSerializer<'a, 'b, W> {
447 writer: &'a mut ValueWriter<'b, W>,
448 key: Option<String>,
449}
450
451impl<'a, 'b, W: Write> SerializeTuple for QsTuplePairSerializer<'a, 'b, W> {
452 type Ok = ();
453 type Error = QsError;
454
455 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
456 where
457 T: Serialize,
458 {
459 if self.key.is_none() {
460 self.key = Some(value.serialize(QsKeySerializer)?);
461 } else {
462 for value in value.serialize(QsValueSerializer)? {
463 self.writer.add_pair(self.key.as_ref().unwrap(), &value)?;
464 }
465 }
466 Ok(())
467 }
468
469 fn end(self) -> Result<Self::Ok, Self::Error> {
470 Ok(())
471 }
472}
473
474struct QsStructSerializer<'a, 'b, W> {
475 writer: &'a mut ValueWriter<'b, W>,
476}
477
478impl<'a, 'b, W: Write> SerializeStruct for QsStructSerializer<'a, 'b, W> {
479 type Ok = ();
480 type Error = QsError;
481
482 fn serialize_field<T: Serialize + ?Sized>(
483 &mut self,
484 key: &'static str,
485 value: &T,
486 ) -> Result<(), Self::Error> {
487 for value in value.serialize(QsValueSerializer)? {
488 self.writer.add_pair(key, &value)?;
489 }
490 Ok(())
491 }
492
493 fn end(self) -> Result<Self::Ok, Self::Error> {
494 Ok(())
495 }
496}
497
498struct QsMapSerializer<'a, 'b, W> {
499 writer: &'a mut ValueWriter<'b, W>,
500 key: Option<String>,
501}
502
503impl<'a, 'b, W: Write> SerializeMap for QsMapSerializer<'a, 'b, W> {
504 type Ok = ();
505 type Error = QsError;
506
507 fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
508 where
509 T: Serialize,
510 {
511 self.key = Some(key.serialize(QsKeySerializer)?);
512 Ok(())
513 }
514
515 fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
516 where
517 T: Serialize,
518 {
519 for value in value.serialize(QsValueSerializer)? {
520 self.writer.add_pair(self.key.as_ref().unwrap(), &value)?;
521 }
522 Ok(())
523 }
524
525 fn end(self) -> Result<Self::Ok, Self::Error> {
526 Ok(())
527 }
528}
529
530struct QsKeySerializer;
531
532impl Serializer for QsKeySerializer {
533 type Ok = String;
534 type Error = QsError;
535 type SerializeSeq = Impossible<String, QsError>;
536 type SerializeTuple = Impossible<String, QsError>;
537 type SerializeTupleStruct = Impossible<String, QsError>;
538 type SerializeTupleVariant = Impossible<String, QsError>;
539 type SerializeMap = Impossible<String, QsError>;
540 type SerializeStruct = Impossible<String, QsError>;
541 type SerializeStructVariant = Impossible<String, QsError>;
542
543 unsupported_types!(
544 (&[u8], serialize_bytes),
545 (bool, serialize_bool),
546 (u8, serialize_u8),
547 (u16, serialize_u16),
548 (u32, serialize_u32),
549 (u64, serialize_u64),
550 (i8, serialize_i8),
551 (i16, serialize_i16),
552 (i32, serialize_i32),
553 (i64, serialize_i64),
554 (f32, serialize_f32),
555 (f64, serialize_f64),
556 (char, serialize_char)
557 );
558
559 serialize_key_to_string!((&str, serialize_str));
560
561 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
562 Err(QsError::Unsupported)
563 }
564
565 fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
566 where
567 T: Serialize,
568 {
569 Err(QsError::Unsupported)
570 }
571
572 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
573 Err(QsError::Unsupported)
574 }
575
576 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
577 Err(QsError::Unsupported)
578 }
579
580 fn serialize_unit_variant(
581 self,
582 _name: &'static str,
583 _variant_index: u32,
584 _variant: &'static str,
585 ) -> Result<Self::Ok, Self::Error> {
586 Err(QsError::Unsupported)
587 }
588
589 fn serialize_newtype_struct<T: ?Sized>(
590 self,
591 _name: &'static str,
592 _value: &T,
593 ) -> Result<Self::Ok, Self::Error>
594 where
595 T: Serialize,
596 {
597 Err(QsError::Unsupported)
598 }
599
600 fn serialize_newtype_variant<T: ?Sized>(
601 self,
602 _name: &'static str,
603 _variant_index: u32,
604 _variant: &'static str,
605 _value: &T,
606 ) -> Result<Self::Ok, Self::Error>
607 where
608 T: Serialize,
609 {
610 Err(QsError::Unsupported)
611 }
612
613 fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
614 Err(QsError::Unsupported)
615 }
616
617 fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
618 Err(QsError::Unsupported)
619 }
620
621 fn serialize_tuple_struct(
622 self,
623 _name: &'static str,
624 _len: usize,
625 ) -> Result<Self::SerializeTupleStruct, Self::Error> {
626 Err(QsError::Unsupported)
627 }
628
629 fn serialize_tuple_variant(
630 self,
631 _name: &'static str,
632 _variant_index: u32,
633 _variant: &'static str,
634 _len: usize,
635 ) -> Result<Self::SerializeTupleVariant, Self::Error> {
636 Err(QsError::Unsupported)
637 }
638
639 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
640 Err(QsError::Unsupported)
641 }
642
643 fn serialize_struct(
644 self,
645 _name: &'static str,
646 _len: usize,
647 ) -> Result<Self::SerializeStruct, Self::Error> {
648 Err(QsError::Unsupported)
649 }
650
651 fn serialize_struct_variant(
652 self,
653 _name: &'static str,
654 _variant_index: u32,
655 _variant: &'static str,
656 _len: usize,
657 ) -> Result<Self::SerializeStructVariant, Self::Error> {
658 Err(QsError::Unsupported)
659 }
660}
661
662struct QsValueSerializer;
663
664impl Serializer for QsValueSerializer {
665 type Ok = Vec<String>;
666 type Error = QsError;
667 type SerializeSeq = QsArrayValueSerializer;
668 type SerializeTuple = Impossible<Vec<String>, QsError>;
669 type SerializeTupleStruct = Impossible<Vec<String>, QsError>;
670 type SerializeTupleVariant = Impossible<Vec<String>, QsError>;
671 type SerializeMap = Impossible<Vec<String>, QsError>;
672 type SerializeStruct = Impossible<Vec<String>, QsError>;
673 type SerializeStructVariant = Impossible<Vec<String>, QsError>;
674
675 unsupported_types!((&[u8], serialize_bytes));
676
677 serialize_value_to_string!(
678 (bool, serialize_bool),
679 (u8, serialize_u8),
680 (u16, serialize_u16),
681 (u32, serialize_u32),
682 (u64, serialize_u64),
683 (i8, serialize_i8),
684 (i16, serialize_i16),
685 (i32, serialize_i32),
686 (i64, serialize_i64),
687 (f32, serialize_f32),
688 (f64, serialize_f64),
689 (char, serialize_char),
690 (&str, serialize_str)
691 );
692
693 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
694 Ok(vec![])
695 }
696
697 fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
698 where
699 T: Serialize,
700 {
701 value.serialize(self)
702 }
703
704 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
705 Ok(vec![String::new()])
706 }
707
708 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
709 Err(QsError::Unsupported)
710 }
711
712 fn serialize_unit_variant(
713 self,
714 _name: &'static str,
715 _variant_index: u32,
716 _variant: &'static str,
717 ) -> Result<Self::Ok, Self::Error> {
718 Err(QsError::Unsupported)
719 }
720
721 fn serialize_newtype_struct<T: ?Sized>(
722 self,
723 _name: &'static str,
724 _value: &T,
725 ) -> Result<Self::Ok, Self::Error>
726 where
727 T: Serialize,
728 {
729 Err(QsError::Unsupported)
730 }
731
732 fn serialize_newtype_variant<T: ?Sized>(
733 self,
734 _name: &'static str,
735 _variant_index: u32,
736 _variant: &'static str,
737 _value: &T,
738 ) -> Result<Self::Ok, Self::Error>
739 where
740 T: Serialize,
741 {
742 Err(QsError::Unsupported)
743 }
744
745 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
746 Ok(QsArrayValueSerializer {
747 values: match len {
748 Some(len) => Vec::with_capacity(len),
749 None => vec![],
750 },
751 })
752 }
753
754 fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
755 Err(QsError::Unsupported)
756 }
757
758 fn serialize_tuple_struct(
759 self,
760 _name: &'static str,
761 _len: usize,
762 ) -> Result<Self::SerializeTupleStruct, Self::Error> {
763 Err(QsError::Unsupported)
764 }
765
766 fn serialize_tuple_variant(
767 self,
768 _name: &'static str,
769 _variant_index: u32,
770 _variant: &'static str,
771 _len: usize,
772 ) -> Result<Self::SerializeTupleVariant, Self::Error> {
773 Err(QsError::Unsupported)
774 }
775
776 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
777 Err(QsError::Unsupported)
778 }
779
780 fn serialize_struct(
781 self,
782 _name: &'static str,
783 _len: usize,
784 ) -> Result<Self::SerializeStruct, Self::Error> {
785 Err(QsError::Unsupported)
786 }
787
788 fn serialize_struct_variant(
789 self,
790 _name: &'static str,
791 _variant_index: u32,
792 _variant: &'static str,
793 _len: usize,
794 ) -> Result<Self::SerializeStructVariant, Self::Error> {
795 Err(QsError::Unsupported)
796 }
797}
798
799struct QsPrimaryValueSerializer;
800
801impl Serializer for QsPrimaryValueSerializer {
802 type Ok = Option<String>;
803 type Error = QsError;
804 type SerializeSeq = Impossible<Option<String>, QsError>;
805 type SerializeTuple = Impossible<Option<String>, QsError>;
806 type SerializeTupleStruct = Impossible<Option<String>, QsError>;
807 type SerializeTupleVariant = Impossible<Option<String>, QsError>;
808 type SerializeMap = Impossible<Option<String>, QsError>;
809 type SerializeStruct = Impossible<Option<String>, QsError>;
810 type SerializeStructVariant = Impossible<Option<String>, QsError>;
811
812 unsupported_types!((&[u8], serialize_bytes));
813
814 serialize_primary_value_to_string!(
815 (bool, serialize_bool),
816 (u8, serialize_u8),
817 (u16, serialize_u16),
818 (u32, serialize_u32),
819 (u64, serialize_u64),
820 (i8, serialize_i8),
821 (i16, serialize_i16),
822 (i32, serialize_i32),
823 (i64, serialize_i64),
824 (f32, serialize_f32),
825 (f64, serialize_f64),
826 (char, serialize_char),
827 (&str, serialize_str)
828 );
829
830 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
831 Ok(None)
832 }
833
834 fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
835 where
836 T: Serialize,
837 {
838 value.serialize(self)
839 }
840
841 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
842 Ok(Some(String::new()))
843 }
844
845 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
846 Err(QsError::Unsupported)
847 }
848
849 fn serialize_unit_variant(
850 self,
851 _name: &'static str,
852 _variant_index: u32,
853 _variant: &'static str,
854 ) -> Result<Self::Ok, Self::Error> {
855 Err(QsError::Unsupported)
856 }
857
858 fn serialize_newtype_struct<T: ?Sized>(
859 self,
860 _name: &'static str,
861 _value: &T,
862 ) -> Result<Self::Ok, Self::Error>
863 where
864 T: Serialize,
865 {
866 Err(QsError::Unsupported)
867 }
868
869 fn serialize_newtype_variant<T: ?Sized>(
870 self,
871 _name: &'static str,
872 _variant_index: u32,
873 _variant: &'static str,
874 _value: &T,
875 ) -> Result<Self::Ok, Self::Error>
876 where
877 T: Serialize,
878 {
879 Err(QsError::Unsupported)
880 }
881
882 fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
883 Err(QsError::Unsupported)
884 }
885
886 fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
887 Err(QsError::Unsupported)
888 }
889
890 fn serialize_tuple_struct(
891 self,
892 _name: &'static str,
893 _len: usize,
894 ) -> Result<Self::SerializeTupleStruct, Self::Error> {
895 Err(QsError::Unsupported)
896 }
897
898 fn serialize_tuple_variant(
899 self,
900 _name: &'static str,
901 _variant_index: u32,
902 _variant: &'static str,
903 _len: usize,
904 ) -> Result<Self::SerializeTupleVariant, Self::Error> {
905 Err(QsError::Unsupported)
906 }
907
908 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
909 Err(QsError::Unsupported)
910 }
911
912 fn serialize_struct(
913 self,
914 _name: &'static str,
915 _len: usize,
916 ) -> Result<Self::SerializeStruct, Self::Error> {
917 Err(QsError::Unsupported)
918 }
919
920 fn serialize_struct_variant(
921 self,
922 _name: &'static str,
923 _variant_index: u32,
924 _variant: &'static str,
925 _len: usize,
926 ) -> Result<Self::SerializeStructVariant, Self::Error> {
927 Err(QsError::Unsupported)
928 }
929}
930
931struct QsArrayValueSerializer {
932 values: Vec<String>,
933}
934
935impl SerializeSeq for QsArrayValueSerializer {
936 type Ok = Vec<String>;
937 type Error = QsError;
938
939 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
940 where
941 T: Serialize,
942 {
943 let value = value.serialize(QsPrimaryValueSerializer)?;
944 self.values.extend(value);
945 Ok(())
946 }
947
948 fn end(self) -> Result<Self::Ok, Self::Error> {
949 Ok(self.values)
950 }
951}
952
953pub(crate) fn to_string<T: Serialize>(value: &T) -> Result<String, QsError> {
954 let mut qs = Vec::new();
955 let mut value_writer = ValueWriter {
956 writer: &mut qs,
957 first: true,
958 };
959 value.serialize(QsSerializer {
960 writer: &mut value_writer,
961 })?;
962 Ok(String::from_utf8(qs).unwrap())
963}
964
965#[cfg(test)]
966mod tests {
967 use std::collections::BTreeMap;
968
969 use super::*;
970
971 #[test]
972 fn serialize_struct() {
973 #[derive(Serialize)]
974 struct Test {
975 a: i32,
976 b: String,
977 c: bool,
978 d: Vec<i32>,
979 e: Vec<String>,
980 }
981
982 let s = to_string(&Test {
983 a: 100,
984 b: "hehe".to_string(),
985 c: true,
986 d: vec![1, 2, 3, 4, 5],
987 e: vec!["abc".to_string(), "def".to_string()],
988 })
989 .unwrap();
990 assert_eq!(s, "a=100&b=hehe&c=true&d=1&d=2&d=3&d=4&d=5&e=abc&e=def");
991 }
992
993 #[test]
994 fn serialize_map() {
995 let map1 = {
996 let mut map = BTreeMap::new();
997 map.insert("a", 100);
998 map.insert("b", 200);
999 map
1000 };
1001
1002 assert_eq!(to_string(&map1).unwrap(), "a=100&b=200");
1003
1004 let map2 = {
1005 let mut map = BTreeMap::new();
1006 map.insert("a", vec![1, 2]);
1007 map.insert("b", vec![3, 4]);
1008 map
1009 };
1010
1011 assert_eq!(to_string(&map2).unwrap(), "a=1&a=2&b=3&b=4");
1012 }
1013
1014 #[test]
1015 fn serialize_optional() {
1016 #[derive(Serialize)]
1017 struct Test {
1018 a: i32,
1019 b: Option<i32>,
1020 c: bool,
1021 }
1022
1023 assert_eq!(
1024 to_string(&Test {
1025 a: 100,
1026 b: None,
1027 c: true
1028 })
1029 .unwrap(),
1030 "a=100&c=true"
1031 );
1032
1033 #[derive(Serialize)]
1034 struct Test2 {
1035 #[serde(rename = "v")]
1036 values: Vec<Option<i32>>,
1037 }
1038
1039 assert_eq!(
1040 to_string(&Test2 {
1041 values: vec![Some(1), None, Some(3)]
1042 })
1043 .unwrap(),
1044 "v=1&v=3"
1045 );
1046 }
1047
1048 #[test]
1049 fn serialize_seq() {
1050 assert_eq!(to_string(&[("a", 123), ("b", 456)]).unwrap(), "a=123&b=456");
1051 assert_eq!(
1052 to_string(&vec![("a", 123), ("b", 456)]).unwrap(),
1053 "a=123&b=456"
1054 );
1055 }
1056
1057 #[test]
1058 fn serialize_tuple() {
1059 assert_eq!(
1060 to_string(&(("a", 123), ("b", 456), ("c", vec![1, 2, 3]))).unwrap(),
1061 "a=123&b=456&c=1&c=2&c=3"
1062 );
1063 }
1064}