csv_stream/
serializer.rs

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

csv_stream/
serializer.rs
