1 use std::{fmt, io, mem};
2
3 use {
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
15 use 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.
serialize<S: Serialize, W: io::Write>( wtr: &mut Writer<W>, value: S, ) -> Result<(), Error>22 pub 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
29 struct SeRecord<'w, W: 'w + io::Write> {
30 wtr: &'w mut Writer<W>,
31 }
32
33 impl<'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
serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error>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
serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error>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
serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error>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
serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error>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
serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>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
serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error>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
serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error>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
serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error>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
serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>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
serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error>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
serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error>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
serialize_char(self, v: char) -> Result<Self::Ok, Self::Error>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
serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error>118 fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {
119 self.wtr.write_field(value)
120 }
121
serialize_bytes(self, value: &[u8]) -> Result<Self::Ok, Self::Error>122 fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok, Self::Error> {
123 self.wtr.write_field(value)
124 }
125
serialize_none(self) -> Result<Self::Ok, Self::Error>126 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
127 self.wtr.write_field(&[])
128 }
129
serialize_some<T: ?Sized + Serialize>( self, value: &T, ) -> Result<Self::Ok, Self::Error>130 fn serialize_some<T: ?Sized + Serialize>(
131 self,
132 value: &T,
133 ) -> Result<Self::Ok, Self::Error> {
134 value.serialize(self)
135 }
136
serialize_unit(self) -> Result<Self::Ok, Self::Error>137 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
138 None::<()>.serialize(self)
139 }
140
serialize_unit_struct( self, name: &'static str, ) -> Result<Self::Ok, Self::Error>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
serialize_unit_variant( self, _name: &'static str, _variant_index: u32, variant: &'static str, ) -> Result<Self::Ok, Self::Error>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
serialize_newtype_struct<T: ?Sized + Serialize>( self, _name: &'static str, value: &T, ) -> Result<Self::Ok, Self::Error>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
serialize_newtype_variant<T: ?Sized + Serialize>( self, _name: &'static str, _variant_index: u32, _variant: &'static str, value: &T, ) -> Result<Self::Ok, Self::Error>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
serialize_seq( self, _len: Option<usize>, ) -> Result<Self::SerializeSeq, Self::Error>175 fn serialize_seq(
176 self,
177 _len: Option<usize>,
178 ) -> Result<Self::SerializeSeq, Self::Error> {
179 Ok(self)
180 }
181
serialize_tuple( self, _len: usize, ) -> Result<Self::SerializeTuple, Self::Error>182 fn serialize_tuple(
183 self,
184 _len: usize,
185 ) -> Result<Self::SerializeTuple, Self::Error> {
186 Ok(self)
187 }
188
serialize_tuple_struct( self, _name: &'static str, _len: usize, ) -> Result<Self::SerializeTupleStruct, Self::Error>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
serialize_tuple_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize, ) -> Result<Self::SerializeTupleVariant, Self::Error>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
serialize_map( self, _len: Option<usize>, ) -> Result<Self::SerializeMap, Self::Error>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
serialize_struct( self, _name: &'static str, _len: usize, ) -> Result<Self::SerializeStruct, Self::Error>219 fn serialize_struct(
220 self,
221 _name: &'static str,
222 _len: usize,
223 ) -> Result<Self::SerializeStruct, Self::Error> {
224 Ok(self)
225 }
226
serialize_struct_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize, ) -> Result<Self::SerializeStructVariant, Self::Error>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
238 impl<'a, 'w, W: io::Write> SerializeSeq for &'a mut SeRecord<'w, W> {
239 type Ok = ();
240 type Error = Error;
241
serialize_element<T: ?Sized + Serialize>( &mut self, value: &T, ) -> Result<(), Self::Error>242 fn serialize_element<T: ?Sized + Serialize>(
243 &mut self,
244 value: &T,
245 ) -> Result<(), Self::Error> {
246 value.serialize(&mut **self)
247 }
248
end(self) -> Result<Self::Ok, Self::Error>249 fn end(self) -> Result<Self::Ok, Self::Error> {
250 Ok(())
251 }
252 }
253
254 impl<'a, 'w, W: io::Write> SerializeTuple for &'a mut SeRecord<'w, W> {
255 type Ok = ();
256 type Error = Error;
257
serialize_element<T: ?Sized + Serialize>( &mut self, value: &T, ) -> Result<(), Self::Error>258 fn serialize_element<T: ?Sized + Serialize>(
259 &mut self,
260 value: &T,
261 ) -> Result<(), Self::Error> {
262 value.serialize(&mut **self)
263 }
264
end(self) -> Result<Self::Ok, Self::Error>265 fn end(self) -> Result<Self::Ok, Self::Error> {
266 Ok(())
267 }
268 }
269
270 impl<'a, 'w, W: io::Write> SerializeTupleStruct for &'a mut SeRecord<'w, W> {
271 type Ok = ();
272 type Error = Error;
273
serialize_field<T: ?Sized + Serialize>( &mut self, value: &T, ) -> Result<(), Self::Error>274 fn serialize_field<T: ?Sized + Serialize>(
275 &mut self,
276 value: &T,
277 ) -> Result<(), Self::Error> {
278 value.serialize(&mut **self)
279 }
280
end(self) -> Result<Self::Ok, Self::Error>281 fn end(self) -> Result<Self::Ok, Self::Error> {
282 Ok(())
283 }
284 }
285
286 impl<'a, 'w, W: io::Write> SerializeTupleVariant for &'a mut SeRecord<'w, W> {
287 type Ok = ();
288 type Error = Error;
289
serialize_field<T: ?Sized + Serialize>( &mut self, _value: &T, ) -> Result<(), Self::Error>290 fn serialize_field<T: ?Sized + Serialize>(
291 &mut self,
292 _value: &T,
293 ) -> Result<(), Self::Error> {
294 unreachable!()
295 }
296
end(self) -> Result<Self::Ok, Self::Error>297 fn end(self) -> Result<Self::Ok, Self::Error> {
298 unreachable!()
299 }
300 }
301
302 impl<'a, 'w, W: io::Write> SerializeMap for &'a mut SeRecord<'w, W> {
303 type Ok = ();
304 type Error = Error;
305
serialize_key<T: ?Sized + Serialize>( &mut self, _key: &T, ) -> Result<(), Self::Error>306 fn serialize_key<T: ?Sized + Serialize>(
307 &mut self,
308 _key: &T,
309 ) -> Result<(), Self::Error> {
310 unreachable!()
311 }
312
serialize_value<T: ?Sized + Serialize>( &mut self, _value: &T, ) -> Result<(), Self::Error>313 fn serialize_value<T: ?Sized + Serialize>(
314 &mut self,
315 _value: &T,
316 ) -> Result<(), Self::Error> {
317 unreachable!()
318 }
319
end(self) -> Result<Self::Ok, Self::Error>320 fn end(self) -> Result<Self::Ok, Self::Error> {
321 unreachable!()
322 }
323 }
324
325 impl<'a, 'w, W: io::Write> SerializeStruct for &'a mut SeRecord<'w, W> {
326 type Ok = ();
327 type Error = Error;
328
serialize_field<T: ?Sized + Serialize>( &mut self, _key: &'static str, value: &T, ) -> Result<(), Self::Error>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
end(self) -> Result<Self::Ok, Self::Error>337 fn end(self) -> Result<Self::Ok, Self::Error> {
338 Ok(())
339 }
340 }
341
342 impl<'a, 'w, W: io::Write> SerializeStructVariant for &'a mut SeRecord<'w, W> {
343 type Ok = ();
344 type Error = Error;
345
serialize_field<T: ?Sized + Serialize>( &mut self, _key: &'static str, _value: &T, ) -> Result<(), Self::Error>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
end(self) -> Result<Self::Ok, Self::Error>354 fn end(self) -> Result<Self::Ok, Self::Error> {
355 unreachable!()
356 }
357 }
358
359 impl SerdeError for Error {
custom<T: fmt::Display>(msg: T) -> Error360 fn custom<T: fmt::Display>(msg: T) -> Error {
361 Error::new(ErrorKind::Serialize(msg.to_string()))
362 }
363 }
364
error_scalar_outside_struct<T: fmt::Display>(name: T) -> Error365 fn 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
error_container_inside_struct<T: fmt::Display>(name: T) -> Error373 fn 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`.
serialize_header<S: Serialize, W: io::Write>( wtr: &mut Writer<W>, value: S, ) -> Result<bool, Error>389 pub 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 /// ```
438 enum 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
451 struct SeHeader<'w, W: 'w + io::Write> {
452 wtr: &'w mut Writer<W>,
453 state: HeaderState,
454 }
455
456 impl<'w, W: io::Write> SeHeader<'w, W> {
new(wtr: &'w mut Writer<W>) -> Self457 fn new(wtr: &'w mut Writer<W>) -> Self {
458 SeHeader { wtr, state: HeaderState::Write }
459 }
460
wrote_header(&self) -> bool461 fn wrote_header(&self) -> bool {
462 use self::HeaderState::*;
463 match self.state {
464 Write | ErrorIfWrite(_) => false,
465 EncounteredStructField | InStructField => true,
466 }
467 }
468
handle_scalar<T: fmt::Display>( &mut self, name: T, ) -> Result<(), Error>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
handle_container<T: fmt::Display>( &mut self, name: T, ) -> Result<&mut Self, Error>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
497 impl<'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
serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error>508 fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
509 self.handle_scalar(v)
510 }
511
serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error>512 fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
513 self.handle_scalar(v)
514 }
515
serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error>516 fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
517 self.handle_scalar(v)
518 }
519
serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error>520 fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
521 self.handle_scalar(v)
522 }
523
serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>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
serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error>534 fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
535 self.handle_scalar(v)
536 }
537
serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error>538 fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
539 self.handle_scalar(v)
540 }
541
serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error>542 fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
543 self.handle_scalar(v)
544 }
545
serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>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
serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error>556 fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
557 self.handle_scalar(v)
558 }
559
serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error>560 fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
561 self.handle_scalar(v)
562 }
563
serialize_char(self, v: char) -> Result<Self::Ok, Self::Error>564 fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
565 self.handle_scalar(v)
566 }
567
serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error>568 fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {
569 self.handle_scalar(value)
570 }
571
serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Self::Error>572 fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Self::Error> {
573 self.handle_scalar("&[u8]")
574 }
575
serialize_none(self) -> Result<Self::Ok, Self::Error>576 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
577 self.handle_scalar("None")
578 }
579
serialize_some<T: ?Sized + Serialize>( self, _value: &T, ) -> Result<Self::Ok, Self::Error>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
serialize_unit(self) -> Result<Self::Ok, Self::Error>587 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
588 self.handle_scalar("()")
589 }
590
serialize_unit_struct( self, name: &'static str, ) -> Result<Self::Ok, Self::Error>591 fn serialize_unit_struct(
592 self,
593 name: &'static str,
594 ) -> Result<Self::Ok, Self::Error> {
595 self.handle_scalar(name)
596 }
597
serialize_unit_variant( self, name: &'static str, _variant_index: u32, variant: &'static str, ) -> Result<Self::Ok, Self::Error>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
serialize_newtype_struct<T: ?Sized + Serialize>( self, name: &'static str, _value: &T, ) -> Result<Self::Ok, Self::Error>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
serialize_newtype_variant<T: ?Sized + Serialize>( self, name: &'static str, _variant_index: u32, variant: &'static str, _value: &T, ) -> Result<Self::Ok, Self::Error>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
serialize_seq( self, _len: Option<usize>, ) -> Result<Self::SerializeSeq, Self::Error>625 fn serialize_seq(
626 self,
627 _len: Option<usize>,
628 ) -> Result<Self::SerializeSeq, Self::Error> {
629 self.handle_container("sequence")
630 }
631
serialize_tuple( self, _len: usize, ) -> Result<Self::SerializeTuple, Self::Error>632 fn serialize_tuple(
633 self,
634 _len: usize,
635 ) -> Result<Self::SerializeTuple, Self::Error> {
636 self.handle_container("tuple")
637 }
638
serialize_tuple_struct( self, name: &'static str, _len: usize, ) -> Result<Self::SerializeTupleStruct, Self::Error>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
serialize_tuple_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize, ) -> Result<Self::SerializeTupleVariant, Self::Error>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
serialize_map( self, _len: Option<usize>, ) -> Result<Self::SerializeMap, Self::Error>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
serialize_struct( self, name: &'static str, _len: usize, ) -> Result<Self::SerializeStruct, Self::Error>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
serialize_struct_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize, ) -> Result<Self::SerializeStructVariant, Self::Error>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
688 impl<'a, 'w, W: io::Write> SerializeSeq for &'a mut SeHeader<'w, W> {
689 type Ok = ();
690 type Error = Error;
691
serialize_element<T: ?Sized + Serialize>( &mut self, value: &T, ) -> Result<(), Self::Error>692 fn serialize_element<T: ?Sized + Serialize>(
693 &mut self,
694 value: &T,
695 ) -> Result<(), Self::Error> {
696 value.serialize(&mut **self)
697 }
698
end(self) -> Result<Self::Ok, Self::Error>699 fn end(self) -> Result<Self::Ok, Self::Error> {
700 Ok(())
701 }
702 }
703
704 impl<'a, 'w, W: io::Write> SerializeTuple for &'a mut SeHeader<'w, W> {
705 type Ok = ();
706 type Error = Error;
707
serialize_element<T: ?Sized + Serialize>( &mut self, value: &T, ) -> Result<(), Self::Error>708 fn serialize_element<T: ?Sized + Serialize>(
709 &mut self,
710 value: &T,
711 ) -> Result<(), Self::Error> {
712 value.serialize(&mut **self)
713 }
714
end(self) -> Result<Self::Ok, Self::Error>715 fn end(self) -> Result<Self::Ok, Self::Error> {
716 Ok(())
717 }
718 }
719
720 impl<'a, 'w, W: io::Write> SerializeTupleStruct for &'a mut SeHeader<'w, W> {
721 type Ok = ();
722 type Error = Error;
723
serialize_field<T: ?Sized + Serialize>( &mut self, value: &T, ) -> Result<(), Self::Error>724 fn serialize_field<T: ?Sized + Serialize>(
725 &mut self,
726 value: &T,
727 ) -> Result<(), Self::Error> {
728 value.serialize(&mut **self)
729 }
730
end(self) -> Result<Self::Ok, Self::Error>731 fn end(self) -> Result<Self::Ok, Self::Error> {
732 Ok(())
733 }
734 }
735
736 impl<'a, 'w, W: io::Write> SerializeTupleVariant for &'a mut SeHeader<'w, W> {
737 type Ok = ();
738 type Error = Error;
739
serialize_field<T: ?Sized + Serialize>( &mut self, _value: &T, ) -> Result<(), Self::Error>740 fn serialize_field<T: ?Sized + Serialize>(
741 &mut self,
742 _value: &T,
743 ) -> Result<(), Self::Error> {
744 unreachable!()
745 }
746
end(self) -> Result<Self::Ok, Self::Error>747 fn end(self) -> Result<Self::Ok, Self::Error> {
748 unreachable!()
749 }
750 }
751
752 impl<'a, 'w, W: io::Write> SerializeMap for &'a mut SeHeader<'w, W> {
753 type Ok = ();
754 type Error = Error;
755
serialize_key<T: ?Sized + Serialize>( &mut self, _key: &T, ) -> Result<(), Self::Error>756 fn serialize_key<T: ?Sized + Serialize>(
757 &mut self,
758 _key: &T,
759 ) -> Result<(), Self::Error> {
760 unreachable!()
761 }
762
serialize_value<T: ?Sized + Serialize>( &mut self, _value: &T, ) -> Result<(), Self::Error>763 fn serialize_value<T: ?Sized + Serialize>(
764 &mut self,
765 _value: &T,
766 ) -> Result<(), Self::Error> {
767 unreachable!()
768 }
769
end(self) -> Result<Self::Ok, Self::Error>770 fn end(self) -> Result<Self::Ok, Self::Error> {
771 unreachable!()
772 }
773 }
774
775 impl<'a, 'w, W: io::Write> SerializeStruct for &'a mut SeHeader<'w, W> {
776 type Ok = ();
777 type Error = Error;
778
serialize_field<T: ?Sized + Serialize>( &mut self, key: &'static str, value: &T, ) -> Result<(), Self::Error>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
end(self) -> Result<Self::Ok, Self::Error>800 fn end(self) -> Result<Self::Ok, Self::Error> {
801 Ok(())
802 }
803 }
804
805 impl<'a, 'w, W: io::Write> SerializeStructVariant for &'a mut SeHeader<'w, W> {
806 type Ok = ();
807 type Error = Error;
808
serialize_field<T: ?Sized + Serialize>( &mut self, _key: &'static str, _value: &T, ) -> Result<(), Self::Error>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
end(self) -> Result<Self::Ok, Self::Error>817 fn end(self) -> Result<Self::Ok, Self::Error> {
818 unreachable!()
819 }
820 }
821
822 #[cfg(test)]
823 mod 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
serialize<S: Serialize>(s: S) -> String836 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.
serialize_header<S: Serialize>(s: S) -> (bool, String)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
serialize_err<S: Serialize>(s: S) -> Error855 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
serialize_header_err<S: Serialize>(s: S) -> Error860 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]
bool()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]
integer()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]
float()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]
float_nan()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]
char()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]
str()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]
bytes()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]
option()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]
unit()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]
struct_unit()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]
struct_newtype()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]
enum_units()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]
enum_newtypes()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]
seq()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]
tuple()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]
tuple_struct()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]
tuple_variant()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]
enum_struct_variant()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]
struct_no_headers()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]
struct_headers()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]
struct_headers_nested()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]
struct_headers_nested_seq()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]
struct_headers_inside_tuple()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]
struct_headers_inside_tuple_scalar_before()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]
struct_headers_inside_tuple_scalar_after()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]
struct_headers_inside_seq()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]
struct_headers_inside_nested_tuple_seq()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 }
1349