csv_async/
serializer.rs

Help
1use std::fmt;
2use std::mem;
3
4use serde::ser::{
5    Error as SerdeError, Serialize, SerializeMap, SerializeSeq,
6    SerializeStruct, SerializeStructVariant, SerializeTuple,
7    SerializeTupleStruct, SerializeTupleVariant, Serializer,
8};
9use serde::serde_if_integer128;
10
11use crate::error::{Error, ErrorKind};
12use crate::async_writers::mwtr_serde::MemWriter;
13
14/// Serialize the given value to the given writer, and return an error if
15/// anything went wrong.
16pub fn serialize<S: Serialize>(
17    wtr: &mut MemWriter,
18    value: S,
19) -> Result<(), Error> {
20    value.serialize(&mut SeRecord { wtr })
21}
22
23struct SeRecord<'w> {
24    wtr: &'w mut MemWriter,
25}
26
27impl<'a, 'w> Serializer for &'a mut SeRecord<'w> {
28    type Ok = ();
29    type Error = Error;
30    type SerializeSeq = Self;
31    type SerializeTuple = Self;
32    type SerializeTupleStruct = Self;
33    type SerializeTupleVariant = Self;
34    type SerializeMap = Self;
35    type SerializeStruct = Self;
36    type SerializeStructVariant = Self;
37
38    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
39        if v {
40            self.wtr.write_field("true")
41        } else {
42            self.wtr.write_field("false")
43        }
44    }
45
46    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
47        let mut buffer = itoa::Buffer::new();
48        self.wtr.write_field(buffer.format(v))
49    }
50
51    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
52        let mut buffer = itoa::Buffer::new();
53        self.wtr.write_field(buffer.format(v))
54    }
55
56    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
57        let mut buffer = itoa::Buffer::new();
58        self.wtr.write_field(buffer.format(v))
59    }
60
61    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
62        let mut buffer = itoa::Buffer::new();
63        self.wtr.write_field(buffer.format(v))
64    }
65
66    serde_if_integer128! {
67        fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
68            self.collect_str(&v)
69        }
70    }
71
72    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
73        let mut buffer = itoa::Buffer::new();
74        self.wtr.write_field(buffer.format(v))
75    }
76
77    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
78        let mut buffer = itoa::Buffer::new();
79        self.wtr.write_field(buffer.format(v))
80    }
81
82    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
83        let mut buffer = itoa::Buffer::new();
84        self.wtr.write_field(buffer.format(v))
85    }
86
87    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
88        let mut buffer = itoa::Buffer::new();
89        self.wtr.write_field(buffer.format(v))
90    }
91
92    serde_if_integer128! {
93        fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
94            self.collect_str(&v)
95        }
96    }
97
98    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
99        let mut buffer = ryu::Buffer::new();
100        self.wtr.write_field(buffer.format(v))
101    }
102
103    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
104        let mut buffer = ryu::Buffer::new();
105        self.wtr.write_field(buffer.format(v))
106    }
107
108    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
109        self.wtr.write_field(v.encode_utf8(&mut [0; 4]))
110    }
111
112    fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {
113        self.wtr.write_field(value)
114    }
115
116    fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok, Self::Error> {
117        self.wtr.write_field(value)
118    }
119
120    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
121        self.wtr.write_field([])
122    }
123
124    fn serialize_some<T: ?Sized + Serialize>(
125        self,
126        value: &T,
127    ) -> Result<Self::Ok, Self::Error> {
128        value.serialize(self)
129    }
130
131    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
132        None::<()>.serialize(self)
133    }
134
135    fn serialize_unit_struct(
136        self,
137        name: &'static str,
138    ) -> Result<Self::Ok, Self::Error> {
139        self.wtr.write_field(name)
140    }
141
142    fn serialize_unit_variant(
143        self,
144        _name: &'static str,
145        _variant_index: u32,
146        variant: &'static str,
147    ) -> Result<Self::Ok, Self::Error> {
148        self.wtr.write_field(variant)
149    }
150
151    fn serialize_newtype_struct<T: ?Sized + Serialize>(
152        self,
153        _name: &'static str,
154        value: &T,
155    ) -> Result<Self::Ok, Self::Error> {
156        value.serialize(self)
157    }
158
159    fn serialize_newtype_variant<T: ?Sized + Serialize>(
160        self,
161        _name: &'static str,
162        _variant_index: u32,
163        _variant: &'static str,
164        value: &T,
165    ) -> Result<Self::Ok, Self::Error> {
166        value.serialize(self)
167    }
168
169    fn serialize_seq(
170        self,
171        _len: Option<usize>,
172    ) -> Result<Self::SerializeSeq, Self::Error> {
173        Ok(self)
174    }
175
176    fn serialize_tuple(
177        self,
178        _len: usize,
179    ) -> Result<Self::SerializeTuple, Self::Error> {
180        Ok(self)
181    }
182
183    fn serialize_tuple_struct(
184        self,
185        _name: &'static str,
186        _len: usize,
187    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
188        Ok(self)
189    }
190
191    fn serialize_tuple_variant(
192        self,
193        _name: &'static str,
194        _variant_index: u32,
195        _variant: &'static str,
196        _len: usize,
197    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
198        Err(Error::custom("serializing enum tuple variants is not supported"))
199    }
200
201    fn serialize_map(
202        self,
203        _len: Option<usize>,
204    ) -> Result<Self::SerializeMap, Self::Error> {
205        // The right behavior for serializing maps isn't clear.
206        Err(Error::custom(
207            "serializing maps is not supported, \
208             if you have a use case, please file an issue at \
209             https://github.com/BurntSushi/rust-csv",
210        ))
211    }
212
213    fn serialize_struct(
214        self,
215        _name: &'static str,
216        _len: usize,
217    ) -> Result<Self::SerializeStruct, Self::Error> {
218        Ok(self)
219    }
220
221    fn serialize_struct_variant(
222        self,
223        _name: &'static str,
224        _variant_index: u32,
225        _variant: &'static str,
226        _len: usize,
227    ) -> Result<Self::SerializeStructVariant, Self::Error> {
228        Err(Error::custom("serializing enum struct variants is not supported"))
229    }
230}
231
232impl<'a, 'w> SerializeSeq for &'a mut SeRecord<'w> {
233    type Ok = ();
234    type Error = Error;
235
236    fn serialize_element<T: ?Sized + Serialize>(
237        &mut self,
238        value: &T,
239    ) -> Result<(), Self::Error> {
240        value.serialize(&mut **self)
241    }
242
243    fn end(self) -> Result<Self::Ok, Self::Error> {
244        Ok(())
245    }
246}
247
248impl<'a, 'w> SerializeTuple for &'a mut SeRecord<'w> {
249    type Ok = ();
250    type Error = Error;
251
252    fn serialize_element<T: ?Sized + Serialize>(
253        &mut self,
254        value: &T,
255    ) -> Result<(), Self::Error> {
256        value.serialize(&mut **self)
257    }
258
259    fn end(self) -> Result<Self::Ok, Self::Error> {
260        Ok(())
261    }
262}
263
264impl<'a, 'w> SerializeTupleStruct for &'a mut SeRecord<'w> {
265    type Ok = ();
266    type Error = Error;
267
268    fn serialize_field<T: ?Sized + Serialize>(
269        &mut self,
270        value: &T,
271    ) -> Result<(), Self::Error> {
272        value.serialize(&mut **self)
273    }
274
275    fn end(self) -> Result<Self::Ok, Self::Error> {
276        Ok(())
277    }
278}
279
280impl<'a, 'w> SerializeTupleVariant for &'a mut SeRecord<'w> {
281    type Ok = ();
282    type Error = Error;
283
284    fn serialize_field<T: ?Sized + Serialize>(
285        &mut self,
286        _value: &T,
287    ) -> Result<(), Self::Error> {
288        unreachable!()
289    }
290
291    fn end(self) -> Result<Self::Ok, Self::Error> {
292        unreachable!()
293    }
294}
295
296impl<'a, 'w> SerializeMap for &'a mut SeRecord<'w> {
297    type Ok = ();
298    type Error = Error;
299
300    fn serialize_key<T: ?Sized + Serialize>(
301        &mut self,
302        _key: &T,
303    ) -> Result<(), Self::Error> {
304        unreachable!()
305    }
306
307    fn serialize_value<T: ?Sized + Serialize>(
308        &mut self,
309        _value: &T,
310    ) -> Result<(), Self::Error> {
311        unreachable!()
312    }
313
314    fn end(self) -> Result<Self::Ok, Self::Error> {
315        unreachable!()
316    }
317}
318
319impl<'a, 'w> SerializeStruct for &'a mut SeRecord<'w> {
320    type Ok = ();
321    type Error = Error;
322
323    fn serialize_field<T: ?Sized + Serialize>(
324        &mut self,
325        _key: &'static str,
326        value: &T,
327    ) -> Result<(), Self::Error> {
328        value.serialize(&mut **self)
329    }
330
331    fn end(self) -> Result<Self::Ok, Self::Error> {
332        Ok(())
333    }
334}
335
336impl<'a, 'w> SerializeStructVariant for &'a mut SeRecord<'w> {
337    type Ok = ();
338    type Error = Error;
339
340    fn serialize_field<T: ?Sized + Serialize>(
341        &mut self,
342        _key: &'static str,
343        _value: &T,
344    ) -> Result<(), Self::Error> {
345        unreachable!()
346    }
347
348    fn end(self) -> Result<Self::Ok, Self::Error> {
349        unreachable!()
350    }
351}
352
353impl SerdeError for Error {
354    fn custom<T: fmt::Display>(msg: T) -> Error {
355        Error::new(ErrorKind::Serialize(msg.to_string()))
356    }
357}
358
359fn error_scalar_outside_struct<T: fmt::Display>(name: T) -> Error {
360    Error::custom(format!(
361        "cannot serialize {} scalar outside struct \
362         when writing headers from structs",
363        name
364    ))
365}
366
367fn error_container_inside_struct<T: fmt::Display>(name: T) -> Error {
368    Error::custom(format!(
369        "cannot serialize {} container inside struct \
370         when writing headers from structs",
371        name
372    ))
373}
374
375/// Write header names corresponding to the field names of the value (if the
376/// value has field names).
377///
378/// If the type to be serialized has field names (e.g. it's a struct), then
379/// header names are written, and the `Ok` return value is `true`.
380///
381/// If the type to be serialized doesn't have field names, then nothing is
382/// written, and the `Ok` return value is `false`.
383pub fn serialize_header<S: Serialize>(
384    wtr: &mut MemWriter,
385    value: S,
386) -> Result<bool, Error> {
387    let mut ser = SeHeader::new(wtr);
388    value.serialize(&mut ser).map(|_| ser.wrote_header())
389}
390
391/// State machine for `SeHeader`.
392///
393/// This is a diagram of the transitions in the state machine. Note that only
394/// some serialization events cause a state transition, and only for certain
395/// states. For example, encountering a scalar causes a transition if the state
396/// is `Write` or `EncounteredStructField`, but not if the state is
397/// `ErrorIfWrite(err)` or `InStructField`.
398///
399/// ```text
400///                              +-----+
401///                              |Write|
402///                              +-----+
403///                                 |
404///              /------------------+------------------\
405///              |                  |                  |
406///          encounter            finish           encounter
407///            scalar               |             struct field
408///              |                  |                  |
409///              v                  v                  v
410///     +-----------------+       Ok(())        +-------------+
411///     |ErrorIfWrite(err)|                     |InStructField|<--------\
412///     +-----------------+                     +-------------+         |
413///              |                                     |                |
414///       /------+------\            /-----------------+                |
415///       |             |            |                 |                |
416///   encounter       finish     encounter          finish          encounter
417///  struct field       |        container           field         struct field
418///       |             |            |                 |                |
419///       v             v            v                 v                |
420///   Err(err)       Ok(())        Err(_)   +----------------------+    |
421///                                         |EncounteredStructField|    |
422///                                         +----------------------+    |
423///                                                    |                |
424///                                         /----------+----------------/
425///                                         |          |
426///                                     encounter    finish
427///                                       scalar       |
428///                                         |          |
429///                                         v          v
430///                                       Err(_)    Ok(())
431/// ```
432enum HeaderState {
433    /// Start here. Headers need to be written if the type has field names.
434    Write,
435    /// The serializer still has not encountered a struct field. If one is
436    /// encountered (headers need to be written), return the enclosed error.
437    ErrorIfWrite(Error),
438    /// The serializer encountered one or more struct fields (and wrote their
439    /// names).
440    EncounteredStructField,
441    /// The serializer is currently in a struct field value.
442    InStructField,
443}
444
445struct SeHeader<'w> {
446    wtr: &'w mut MemWriter,
447    state: HeaderState,
448}
449
450impl<'w> SeHeader<'w> {
451    fn new(wtr: &'w mut MemWriter) -> Self {
452        SeHeader { wtr, state: HeaderState::Write }
453    }
454
455    fn wrote_header(&self) -> bool {
456        use self::HeaderState::*;
457        match self.state {
458            Write | ErrorIfWrite(_) => false,
459            EncounteredStructField | InStructField => true,
460        }
461    }
462
463    fn handle_scalar<T: fmt::Display>(
464        &mut self,
465        name: T,
466    ) -> Result<(), Error> {
467        use self::HeaderState::*;
468
469        match self.state {
470            Write => {
471                self.state = ErrorIfWrite(error_scalar_outside_struct(name));
472                Ok(())
473            }
474            ErrorIfWrite(_) | InStructField => Ok(()),
475            EncounteredStructField => Err(error_scalar_outside_struct(name)),
476        }
477    }
478
479    fn handle_container<T: fmt::Display>(
480        &mut self,
481        name: T,
482    ) -> Result<&mut Self, Error> {
483        if let HeaderState::InStructField = self.state {
484            Err(error_container_inside_struct(name))
485        } else {
486            Ok(self)
487        }
488    }
489}
490
491impl<'a, 'w> Serializer for &'a mut SeHeader<'w> {
492    type Ok = ();
493    type Error = Error;
494    type SerializeSeq = Self;
495    type SerializeTuple = Self;
496    type SerializeTupleStruct = Self;
497    type SerializeTupleVariant = Self;
498    type SerializeMap = Self;
499    type SerializeStruct = Self;
500    type SerializeStructVariant = Self;
501
502    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
503        self.handle_scalar(v)
504    }
505
506    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
507        self.handle_scalar(v)
508    }
509
510    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
511        self.handle_scalar(v)
512    }
513
514    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
515        self.handle_scalar(v)
516    }
517
518    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
519        self.handle_scalar(v)
520    }
521
522    serde_if_integer128! {
523        fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
524            self.handle_scalar(v)
525        }
526    }
527
528    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
529        self.handle_scalar(v)
530    }
531
532    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
533        self.handle_scalar(v)
534    }
535
536    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
537        self.handle_scalar(v)
538    }
539
540    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
541        self.handle_scalar(v)
542    }
543
544    serde_if_integer128! {
545        fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
546            self.handle_scalar(v)
547        }
548    }
549
550    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
551        self.handle_scalar(v)
552    }
553
554    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
555        self.handle_scalar(v)
556    }
557
558    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
559        self.handle_scalar(v)
560    }
561
562    fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {
563        self.handle_scalar(value)
564    }
565
566    fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Self::Error> {
567        self.handle_scalar("&[u8]")
568    }
569
570    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
571        self.handle_scalar("None")
572    }
573
574    fn serialize_some<T: ?Sized + Serialize>(
575        self,
576        _value: &T,
577    ) -> Result<Self::Ok, Self::Error> {
578        self.handle_scalar("Some(_)")
579    }
580
581    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
582        self.handle_scalar("()")
583    }
584
585    fn serialize_unit_struct(
586        self,
587        name: &'static str,
588    ) -> Result<Self::Ok, Self::Error> {
589        self.handle_scalar(name)
590    }
591
592    fn serialize_unit_variant(
593        self,
594        name: &'static str,
595        _variant_index: u32,
596        variant: &'static str,
597    ) -> Result<Self::Ok, Self::Error> {
598        self.handle_scalar(format!("{}::{}", name, variant))
599    }
600
601    fn serialize_newtype_struct<T: ?Sized + Serialize>(
602        self,
603        name: &'static str,
604        _value: &T,
605    ) -> Result<Self::Ok, Self::Error> {
606        self.handle_scalar(format!("{}(_)", name))
607    }
608
609    fn serialize_newtype_variant<T: ?Sized + Serialize>(
610        self,
611        name: &'static str,
612        _variant_index: u32,
613        variant: &'static str,
614        _value: &T,
615    ) -> Result<Self::Ok, Self::Error> {
616        self.handle_scalar(format!("{}::{}(_)", name, variant))
617    }
618
619    fn serialize_seq(
620        self,
621        _len: Option<usize>,
622    ) -> Result<Self::SerializeSeq, Self::Error> {
623        self.handle_container("sequence")
624    }
625
626    fn serialize_tuple(
627        self,
628        _len: usize,
629    ) -> Result<Self::SerializeTuple, Self::Error> {
630        self.handle_container("tuple")
631    }
632
633    fn serialize_tuple_struct(
634        self,
635        name: &'static str,
636        _len: usize,
637    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
638        self.handle_container(name)
639    }
640
641    fn serialize_tuple_variant(
642        self,
643        _name: &'static str,
644        _variant_index: u32,
645        _variant: &'static str,
646        _len: usize,
647    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
648        Err(Error::custom("serializing enum tuple variants is not supported"))
649    }
650
651    fn serialize_map(
652        self,
653        _len: Option<usize>,
654    ) -> Result<Self::SerializeMap, Self::Error> {
655        // The right behavior for serializing maps isn't clear.
656        Err(Error::custom(
657            "serializing maps is not supported, \
658             if you have a use case, please file an issue at \
659             https://github.com/BurntSushi/rust-csv",
660        ))
661    }
662
663    fn serialize_struct(
664        self,
665        name: &'static str,
666        _len: usize,
667    ) -> Result<Self::SerializeStruct, Self::Error> {
668        self.handle_container(name)
669    }
670
671    fn serialize_struct_variant(
672        self,
673        _name: &'static str,
674        _variant_index: u32,
675        _variant: &'static str,
676        _len: usize,
677    ) -> Result<Self::SerializeStructVariant, Self::Error> {
678        Err(Error::custom("serializing enum struct variants is not supported"))
679    }
680}
681
682impl<'a, 'w> SerializeSeq for &'a mut SeHeader<'w> {
683    type Ok = ();
684    type Error = Error;
685
686    fn serialize_element<T: ?Sized + Serialize>(
687        &mut self,
688        value: &T,
689    ) -> Result<(), Self::Error> {
690        value.serialize(&mut **self)
691    }
692
693    fn end(self) -> Result<Self::Ok, Self::Error> {
694        Ok(())
695    }
696}
697
698impl<'a, 'w> SerializeTuple for &'a mut SeHeader<'w> {
699    type Ok = ();
700    type Error = Error;
701
702    fn serialize_element<T: ?Sized + Serialize>(
703        &mut self,
704        value: &T,
705    ) -> Result<(), Self::Error> {
706        value.serialize(&mut **self)
707    }
708
709    fn end(self) -> Result<Self::Ok, Self::Error> {
710        Ok(())
711    }
712}
713
714impl<'a, 'w> SerializeTupleStruct for &'a mut SeHeader<'w> {
715    type Ok = ();
716    type Error = Error;
717
718    fn serialize_field<T: ?Sized + Serialize>(
719        &mut self,
720        value: &T,
721    ) -> Result<(), Self::Error> {
722        value.serialize(&mut **self)
723    }
724
725    fn end(self) -> Result<Self::Ok, Self::Error> {
726        Ok(())
727    }
728}
729
730impl<'a, 'w> SerializeTupleVariant for &'a mut SeHeader<'w> {
731    type Ok = ();
732    type Error = Error;
733
734    fn serialize_field<T: ?Sized + Serialize>(
735        &mut self,
736        _value: &T,
737    ) -> Result<(), Self::Error> {
738        unreachable!()
739    }
740
741    fn end(self) -> Result<Self::Ok, Self::Error> {
742        unreachable!()
743    }
744}
745
746impl<'a, 'w> SerializeMap for &'a mut SeHeader<'w> {
747    type Ok = ();
748    type Error = Error;
749
750    fn serialize_key<T: ?Sized + Serialize>(
751        &mut self,
752        _key: &T,
753    ) -> Result<(), Self::Error> {
754        unreachable!()
755    }
756
757    fn serialize_value<T: ?Sized + Serialize>(
758        &mut self,
759        _value: &T,
760    ) -> Result<(), Self::Error> {
761        unreachable!()
762    }
763
764    fn end(self) -> Result<Self::Ok, Self::Error> {
765        unreachable!()
766    }
767}
768
769impl<'a, 'w> SerializeStruct for &'a mut SeHeader<'w> {
770    type Ok = ();
771    type Error = Error;
772
773    fn serialize_field<T: ?Sized + Serialize>(
774        &mut self,
775        key: &'static str,
776        value: &T,
777    ) -> Result<(), Self::Error> {
778        // Grab old state and update state to `EncounteredStructField`.
779        let old_state =
780            mem::replace(&mut self.state, HeaderState::EncounteredStructField);
781        if let HeaderState::ErrorIfWrite(err) = old_state {
782            return Err(err);
783        }
784        self.wtr.write_field(key)?;
785
786        // Check that there aren't any containers in the value.
787        self.state = HeaderState::InStructField;
788        value.serialize(&mut **self)?;
789        self.state = HeaderState::EncounteredStructField;
790
791        Ok(())
792    }
793
794    fn end(self) -> Result<Self::Ok, Self::Error> {
795        Ok(())
796    }
797}
798
799impl<'a, 'w> SerializeStructVariant for &'a mut SeHeader<'w> {
800    type Ok = ();
801    type Error = Error;
802
803    fn serialize_field<T: ?Sized + Serialize>(
804        &mut self,
805        _key: &'static str,
806        _value: &T,
807    ) -> Result<(), Self::Error> {
808        unreachable!()
809    }
810
811    fn end(self) -> Result<Self::Ok, Self::Error> {
812        unreachable!()
813    }
814}
815
816#[cfg(test)]
817mod tests {
818    use bstr::ByteSlice;
819    use serde::{serde_if_integer128, Serialize};
820
821    use crate::error::{Error, ErrorKind};
822    use crate::async_writers::mwtr_serde::MemWriter;
823
824    use super::{SeHeader, SeRecord};
825
826    fn serialize<S: Serialize>(s: S) -> String {
827        let mut wtr = MemWriter::default();
828        s.serialize(&mut SeRecord { wtr: &mut wtr }).unwrap();
829        wtr.write_record(None::<&[u8]>).unwrap();
830        String::from_utf8(wtr.into_inner().unwrap()).unwrap()
831    }
832
833    /// Serialize using `SeHeader`. Returns whether a header was written and
834    /// the output of the writer.
835    fn serialize_header<S: Serialize>(s: S) -> (bool, String) {
836        let mut wtr = MemWriter::default();
837        let wrote = {
838            let mut ser = SeHeader::new(&mut wtr);
839            s.serialize(&mut ser).unwrap();
840            ser.wrote_header()
841        };
842        (wrote, String::from_utf8(wtr.into_inner().unwrap()).unwrap())
843    }
844
845    fn serialize_err<S: Serialize>(s: S) -> Error {
846        let mut wtr = MemWriter::default();
847        s.serialize(&mut SeRecord { wtr: &mut wtr }).unwrap_err()
848    }
849
850    fn serialize_header_err<S: Serialize>(s: S) -> Error {
851        let mut wtr = MemWriter::default();
852        s.serialize(&mut SeHeader::new(&mut wtr)).unwrap_err()
853    }
854
855    #[test]
856    fn bool() {
857        let got = serialize(true);
858        assert_eq!(got, "true\n");
859        let (wrote, got) = serialize_header(true);
860        assert!(!wrote);
861        assert_eq!(got, "");
862    }
863
864    #[test]
865    fn integer() {
866        let got = serialize(12345);
867        assert_eq!(got, "12345\n");
868        let (wrote, got) = serialize_header(12345);
869        assert!(!wrote);
870        assert_eq!(got, "");
871    }
872
873    serde_if_integer128! {
874        #[test]
875        fn integer_u128() {
876            let got = serialize(i128::max_value() as u128 + 1);
877            assert_eq!(got, "170141183460469231731687303715884105728\n");
878            let (wrote, got) = serialize_header(12345);
879            assert!(!wrote);
880            assert_eq!(got, "");
881        }
882
883        #[test]
884        fn integer_i128() {
885            let got = serialize(i128::max_value());
886            assert_eq!(got, "170141183460469231731687303715884105727\n");
887            let (wrote, got) = serialize_header(12345);
888            assert!(!wrote);
889            assert_eq!(got, "");
890        }
891    }
892
893    #[test]
894    fn float() {
895        let got = serialize(1.23);
896        assert_eq!(got, "1.23\n");
897        let (wrote, got) = serialize_header(1.23);
898        assert!(!wrote);
899        assert_eq!(got, "");
900    }
901
902    #[test]
903    fn float_nan() {
904        let got = serialize(::std::f64::NAN);
905        assert_eq!(got, "NaN\n");
906        let (wrote, got) = serialize_header(::std::f64::NAN);
907        assert!(!wrote);
908        assert_eq!(got, "");
909    }
910
911    #[test]
912    fn char() {
913        let got = serialize('☃');
914        assert_eq!(got, "☃\n");
915        let (wrote, got) = serialize_header('☃');
916        assert!(!wrote);
917        assert_eq!(got, "");
918    }
919
920    #[test]
921    fn str() {
922        let got = serialize("how\nare\n\"you\"?");
923        assert_eq!(got, "\"how\nare\n\"\"you\"\"?\"\n");
924        let (wrote, got) = serialize_header("how\nare\n\"you\"?");
925        assert!(!wrote);
926        assert_eq!(got, "");
927    }
928
929    #[test]
930    fn bytes() {
931        let got = serialize(b"how\nare\n\"you\"?".as_bstr());
932        assert_eq!(got, "\"how\nare\n\"\"you\"\"?\"\n");
933        let (wrote, got) = serialize_header(&b"how\nare\n\"you\"?"[..]);
934        assert!(!wrote);
935        assert_eq!(got, "");
936    }
937
938    #[test]
939    fn option() {
940        let got = serialize(None::<()>);
941        assert_eq!(got, "\"\"\n");
942        let (wrote, got) = serialize_header(None::<()>);
943        assert!(!wrote);
944        assert_eq!(got, "");
945
946        let got = serialize(Some(5));
947        assert_eq!(got, "5\n");
948        let (wrote, got) = serialize_header(Some(5));
949        assert!(!wrote);
950        assert_eq!(got, "");
951    }
952
953    #[test]
954    fn unit() {
955        let got = serialize(());
956        assert_eq!(got, "\"\"\n");
957        let (wrote, got) = serialize_header(());
958        assert!(!wrote);
959        assert_eq!(got, "");
960
961        let got = serialize((5, ()));
962        assert_eq!(got, "5,\n");
963        let (wrote, got) = serialize_header(());
964        assert!(!wrote);
965        assert_eq!(got, "");
966    }
967
968    #[test]
969    fn struct_unit() {
970        #[derive(Serialize)]
971        struct Foo;
972
973        let got = serialize(Foo);
974        assert_eq!(got, "Foo\n");
975        let (wrote, got) = serialize_header(Foo);
976        assert!(!wrote);
977        assert_eq!(got, "");
978    }
979
980    #[test]
981    fn struct_newtype() {
982        #[derive(Serialize)]
983        struct Foo(f64);
984
985        let got = serialize(Foo(1.5));
986        assert_eq!(got, "1.5\n");
987        let (wrote, got) = serialize_header(Foo(1.5));
988        assert!(!wrote);
989        assert_eq!(got, "");
990    }
991
992    #[test]
993    fn enum_units() {
994        #[derive(Serialize)]
995        enum Wat {
996            Foo,
997            Bar,
998            Baz,
999        }
1000
1001        let got = serialize(Wat::Foo);
1002        assert_eq!(got, "Foo\n");
1003        let (wrote, got) = serialize_header(Wat::Foo);
1004        assert!(!wrote);
1005        assert_eq!(got, "");
1006
1007        let got = serialize(Wat::Bar);
1008        assert_eq!(got, "Bar\n");
1009        let (wrote, got) = serialize_header(Wat::Bar);
1010        assert!(!wrote);
1011        assert_eq!(got, "");
1012
1013        let got = serialize(Wat::Baz);
1014        assert_eq!(got, "Baz\n");
1015        let (wrote, got) = serialize_header(Wat::Baz);
1016        assert!(!wrote);
1017        assert_eq!(got, "");
1018    }
1019
1020    #[test]
1021    fn enum_newtypes() {
1022        #[derive(Serialize)]
1023        enum Wat {
1024            Foo(i32),
1025            Bar(f32),
1026            Baz(bool),
1027        }
1028
1029        let got = serialize(Wat::Foo(5));
1030        assert_eq!(got, "5\n");
1031        let (wrote, got) = serialize_header(Wat::Foo(5));
1032        assert!(!wrote);
1033        assert_eq!(got, "");
1034
1035        let got = serialize(Wat::Bar(1.5));
1036        assert_eq!(got, "1.5\n");
1037        let (wrote, got) = serialize_header(Wat::Bar(1.5));
1038        assert!(!wrote);
1039        assert_eq!(got, "");
1040
1041        let got = serialize(Wat::Baz(true));
1042        assert_eq!(got, "true\n");
1043        let (wrote, got) = serialize_header(Wat::Baz(true));
1044        assert!(!wrote);
1045        assert_eq!(got, "");
1046    }
1047
1048    #[test]
1049    fn seq() {
1050        let got = serialize(vec![1, 2, 3]);
1051        assert_eq!(got, "1,2,3\n");
1052        let (wrote, got) = serialize_header(vec![1, 2, 3]);
1053        assert!(!wrote);
1054        assert_eq!(got, "");
1055    }
1056
1057    #[test]
1058    fn tuple() {
1059        let row = (true, 1.5, "hi");
1060        let got = serialize(row.clone());
1061        assert_eq!(got, "true,1.5,hi\n");
1062        let (wrote, got) = serialize_header(row.clone());
1063        assert!(!wrote);
1064        assert_eq!(got, "");
1065
1066        let row = (true, 1.5, vec![1, 2, 3]);
1067        let got = serialize(row.clone());
1068        assert_eq!(got, "true,1.5,1,2,3\n");
1069        let (wrote, got) = serialize_header(row.clone());
1070        assert!(!wrote);
1071        assert_eq!(got, "");
1072    }
1073
1074    #[test]
1075    fn tuple_struct() {
1076        #[derive(Clone, Serialize)]
1077        struct Foo(bool, i32, String);
1078
1079        let row = Foo(false, 42, "hi".to_string());
1080        let got = serialize(row.clone());
1081        assert_eq!(got, "false,42,hi\n");
1082        let (wrote, got) = serialize_header(row.clone());
1083        assert!(!wrote);
1084        assert_eq!(got, "");
1085    }
1086
1087    #[test]
1088    fn tuple_variant() {
1089        #[derive(Clone, Serialize)]
1090        enum Foo {
1091            X(bool, i32, String),
1092        }
1093
1094        let row = Foo::X(false, 42, "hi".to_string());
1095        let err = serialize_err(row.clone());
1096        match *err.kind() {
1097            ErrorKind::Serialize(_) => {
1098                assert!(err.to_string().starts_with("CSV serialize error:"));
1099            }
1100            ref x => panic!("expected ErrorKind::Serialize but got '{:?}'", x),
1101        }
1102        let err = serialize_header_err(row.clone());
1103        match *err.kind() {
1104            ErrorKind::Serialize(_) => {
1105                assert!(err.to_string().starts_with("CSV serialize error:"));
1106            }
1107            ref x => panic!("expected ErrorKind::Serialize but got '{:?}'", x),
1108        }
1109    }
1110
1111    #[test]
1112    fn enum_struct_variant() {
1113        #[derive(Clone, Serialize)]
1114        enum Foo {
1115            X { a: bool, b: i32, c: String },
1116        }
1117
1118        let row = Foo::X { a: false, b: 1, c: "hi".into() };
1119        let err = serialize_err(row.clone());
1120        match *err.kind() {
1121            ErrorKind::Serialize(_) => {}
1122            ref x => panic!("expected ErrorKind::Serialize but got '{:?}'", x),
1123        }
1124        let err = serialize_header_err(row.clone());
1125        match *err.kind() {
1126            ErrorKind::Serialize(_) => {}
1127            ref x => panic!("expected ErrorKind::Serialize but got '{:?}'", x),
1128        }
1129    }
1130
1131    #[test]
1132    fn struct_no_headers() {
1133        #[derive(Serialize)]
1134        struct Foo {
1135            x: bool,
1136            y: i32,
1137            z: String,
1138        }
1139
1140        let got = serialize(Foo { x: true, y: 5, z: "hi".into() });
1141        assert_eq!(got, "true,5,hi\n");
1142    }
1143
1144    serde_if_integer128! {
1145        #[test]
1146        fn struct_no_headers_128() {
1147            #[derive(Serialize)]
1148            struct Foo {
1149                x: i128,
1150                y: u128,
1151            }
1152
1153            let got =
1154                serialize(Foo { x: i128::max_value(), y: u128::max_value() });
1155            assert_eq!(
1156                got,
1157                "170141183460469231731687303715884105727,\
1158                 340282366920938463463374607431768211455\n"
1159            );
1160        }
1161    }
1162
1163    #[test]
1164    fn struct_headers() {
1165        #[derive(Clone, Serialize)]
1166        struct Foo {
1167            x: bool,
1168            y: i32,
1169            z: String,
1170        }
1171
1172        let row = Foo { x: true, y: 5, z: "hi".into() };
1173        let (wrote, got) = serialize_header(row.clone());
1174        assert!(wrote);
1175        assert_eq!(got, "x,y,z");
1176        let got = serialize(row.clone());
1177        assert_eq!(got, "true,5,hi\n");
1178    }
1179
1180    #[test]
1181    fn struct_headers_nested() {
1182        #[derive(Clone, Serialize)]
1183        struct Foo {
1184            label: String,
1185            nest: Nested,
1186        }
1187        #[derive(Clone, Serialize)]
1188        struct Nested {
1189            label2: String,
1190            value: i32,
1191        }
1192
1193        let row = Foo {
1194            label: "foo".into(),
1195            nest: Nested { label2: "bar".into(), value: 5 },
1196        };
1197
1198        let got = serialize(row.clone());
1199        assert_eq!(got, "foo,bar,5\n");
1200
1201        let err = serialize_header_err(row.clone());
1202        match *err.kind() {
1203            ErrorKind::Serialize(_) => {}
1204            ref x => panic!("expected ErrorKind::Serialize but got '{:?}'", x),
1205        }
1206    }
1207
1208    #[test]
1209    fn struct_headers_nested_seq() {
1210        #[derive(Clone, Serialize)]
1211        struct Foo {
1212            label: String,
1213            values: Vec<i32>,
1214        }
1215        let row = Foo { label: "foo".into(), values: vec![1, 2, 3] };
1216
1217        let got = serialize(row.clone());
1218        assert_eq!(got, "foo,1,2,3\n");
1219
1220        let err = serialize_header_err(row.clone());
1221        match *err.kind() {
1222            ErrorKind::Serialize(_) => {}
1223            ref x => panic!("expected ErrorKind::Serialize but got '{:?}'", x),
1224        }
1225    }
1226
1227    #[test]
1228    fn struct_headers_inside_tuple() {
1229        #[derive(Clone, Serialize)]
1230        struct Foo {
1231            label: String,
1232            num: f64,
1233        }
1234        #[derive(Clone, Serialize)]
1235        struct Bar {
1236            label2: bool,
1237            value: i32,
1238            empty: (),
1239        }
1240        let row = (
1241            Foo { label: "hi".to_string(), num: 5.0 },
1242            Bar { label2: true, value: 3, empty: () },
1243            Foo { label: "baz".to_string(), num: 2.3 },
1244        );
1245
1246        let got = serialize(row.clone());
1247        assert_eq!(got, "hi,5.0,true,3,,baz,2.3\n");
1248
1249        let (wrote, got) = serialize_header(row.clone());
1250        assert!(wrote);
1251        assert_eq!(got, "label,num,label2,value,empty,label,num");
1252    }
1253
1254    #[test]
1255    fn struct_headers_inside_tuple_scalar_before() {
1256        #[derive(Clone, Serialize)]
1257        struct Foo {
1258            label: String,
1259            num: f64,
1260        }
1261        let row = (3.14, Foo { label: "hi".to_string(), num: 5.0 });
1262
1263        let got = serialize(row.clone());
1264        assert_eq!(got, "3.14,hi,5.0\n");
1265
1266        let err = serialize_header_err(row.clone());
1267        match *err.kind() {
1268            ErrorKind::Serialize(_) => {}
1269            ref x => panic!("expected ErrorKind::Serialize but got '{:?}'", x),
1270        }
1271    }
1272
1273    #[test]
1274    fn struct_headers_inside_tuple_scalar_after() {
1275        #[derive(Clone, Serialize)]
1276        struct Foo {
1277            label: String,
1278            num: f64,
1279        }
1280        let row = (Foo { label: "hi".to_string(), num: 5.0 }, 3.14);
1281
1282        let got = serialize(row.clone());
1283        assert_eq!(got, "hi,5.0,3.14\n");
1284
1285        let err = serialize_header_err(row.clone());
1286        match *err.kind() {
1287            ErrorKind::Serialize(_) => {}
1288            ref x => panic!("expected ErrorKind::Serialize but got '{:?}'", x),
1289        }
1290    }
1291
1292    #[test]
1293    fn struct_headers_inside_seq() {
1294        #[derive(Clone, Serialize)]
1295        struct Foo {
1296            label: String,
1297            num: f64,
1298        }
1299        let row = vec![
1300            Foo { label: "hi".to_string(), num: 5.0 },
1301            Foo { label: "baz".to_string(), num: 2.3 },
1302        ];
1303
1304        let got = serialize(row.clone());
1305        assert_eq!(got, "hi,5.0,baz,2.3\n");
1306
1307        let (wrote, got) = serialize_header(row.clone());
1308        assert!(wrote);
1309        assert_eq!(got, "label,num,label,num");
1310    }
1311
1312    #[test]
1313    fn struct_headers_inside_nested_tuple_seq() {
1314        #[derive(Clone, Serialize)]
1315        struct Foo {
1316            label: String,
1317            num: f64,
1318        }
1319        #[derive(Clone, Serialize)]
1320        struct Bar {
1321            label2: Baz,
1322            value: i32,
1323            empty: (),
1324        }
1325        #[derive(Clone, Serialize)]
1326        struct Baz(bool);
1327        let row = (
1328            (
1329                Foo { label: "hi".to_string(), num: 5.0 },
1330                Bar { label2: Baz(true), value: 3, empty: () },
1331            ),
1332            vec![(Foo { label: "baz".to_string(), num: 2.3 },)],
1333        );
1334
1335        let got = serialize(row.clone());
1336        assert_eq!(got, "hi,5.0,true,3,,baz,2.3\n");
1337
1338        let (wrote, got) = serialize_header(row.clone());
1339        assert!(wrote);
1340        assert_eq!(got, "label,num,label2,value,empty,label,num");
1341    }
1342}
1343
csv_async/serializer.rs

csv_async/
serializer.rs
