csv/
serializer.rs

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

csv/
serializer.rs
