csv/
serializer.rs

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

csv/
serializer.rs
