serde_x12/
ser.rs

1use std::fmt::{Display, Formatter};
2
3use serde::{ser, Serialize};
4
5use colored::Colorize;
6
7use crate::de::{is_container_element, is_segment};
8use crate::formatter::{Level, VisualSeparator};
9use crate::X12Formatter;
10
11pub fn to_string<T>(value: &T) -> Result<String, X12SerializerError>
12    where
13        T: ser::Serialize,
14{
15    let mut inner = X12Serializer::default();
16    let ser = SerState {
17        delimiter: inner.formatter.segment_delimiter,
18        ser: &mut inner,
19        level: Level::Segment,
20    };
21    value.serialize(ser)?;
22    Ok(inner.to_string())
23}
24
25#[derive(Debug)]
26pub enum X12SerializerError {
27    GenericError(String),
28}
29
30impl std::error::Error for X12SerializerError {}
31
32impl Display for X12SerializerError {
33    fn fmt(&self, _f: &mut Formatter<'_>) -> std::fmt::Result {
34        todo!()
35    }
36}
37
38impl ser::Error for X12SerializerError {
39    fn custom<T: Display>(msg: T) -> Self {
40        X12SerializerError::GenericError(msg.to_string())
41    }
42}
43
44pub struct X12Serializer {
45    output: Vec<u8>,
46    formatter: X12Formatter,
47}
48
49pub struct SerState<'ser> {
50    pub(crate) ser: &'ser mut X12Serializer,
51    pub(crate) delimiter: u8,
52    pub(crate) level: Level,
53}
54
55pub struct SerStruct<'ser> {
56    ser: &'ser mut X12Serializer,
57    delimiter: u8,
58    level: Level,
59    skip: bool,
60    name: &'static str,
61}
62
63impl<'ser> SerStruct<'ser> {
64    pub fn new(ser: &'ser mut X12Serializer, level: Level) -> SerStruct<'ser> {
65        Self {
66            delimiter: ser.formatter.delimiter(level),
67            ser,
68            level,
69            skip: false,
70            name: "",
71        }
72    }
73}
74
75impl<'ser> SerState<'ser> {
76    pub fn new(ser: &'ser mut X12Serializer, level: Level) -> SerState<'ser> {
77        Self {
78            delimiter: ser.formatter.delimiter(level),
79            ser,
80            level,
81        }
82    }
83}
84
85impl Default for X12Serializer {
86    fn default() -> Self {
87        let formatter = X12Formatter::default();
88        Self {
89            output: Vec::new(),
90            formatter,
91        }
92    }
93}
94
95impl X12Serializer {
96    pub fn to_string(self) -> String {
97        String::from_utf8(self.output).unwrap()
98    }
99
100    pub fn new(formatter: X12Formatter) -> Self {
101        Self {
102            output: Vec::new(),
103            formatter,
104        }
105    }
106}
107
108
109impl<'ser> ser::Serializer for SerState<'ser> {
110    type Ok = ();
111    type Error = X12SerializerError;
112    type SerializeSeq = Self;
113    type SerializeTuple = Self;
114    type SerializeTupleStruct = Self;
115    type SerializeTupleVariant = Self;
116    type SerializeMap = Self;
117    type SerializeStruct = SerStruct<'ser>;
118    type SerializeStructVariant = Self;
119
120    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
121        todo!()
122    }
123
124    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
125        todo!()
126    }
127
128    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
129        todo!()
130    }
131
132    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
133        todo!()
134    }
135
136    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
137        todo!()
138    }
139
140    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
141        todo!()
142    }
143
144    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
145        todo!()
146    }
147
148    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
149        todo!()
150    }
151
152    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
153        todo!()
154    }
155
156    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
157        todo!()
158    }
159
160    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
161        todo!()
162    }
163
164    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
165        todo!()
166    }
167
168    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
169        self.ser.output.extend_from_slice(v.as_bytes());
170        Ok(())
171    }
172
173    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
174        self.ser.output.extend_from_slice(v);
175        Ok(())
176    }
177
178    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
179        // paired with logic after serialize in SerStruct
180        // if self.level != Level::Segment {
181        //     self.ser.output.pop();
182        // }
183        Ok(())
184    }
185
186    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error> where T: Serialize {
187        value.serialize(self)
188    }
189
190    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
191        todo!()
192    }
193
194    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
195        todo!()
196    }
197
198    fn serialize_unit_variant(self, name: &'static str, variant_index: u32, variant: &'static str) -> Result<Self::Ok, Self::Error> {
199        todo!()
200    }
201
202    fn serialize_newtype_struct<T: ?Sized>(self, name: &'static str, value: &T) -> Result<Self::Ok, Self::Error> where T: Serialize {
203        todo!()
204    }
205
206    fn serialize_newtype_variant<T: ?Sized>(mut self, name: &'static str, variant_index: u32, variant: &'static str, value: &T) -> Result<Self::Ok, Self::Error> where T: Serialize {
207        todo!()
208    }
209
210    fn serialize_seq(mut self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
211        // eprintln!("serialize_seq: {:?}", len);
212        Ok(self)
213    }
214
215    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
216        todo!()
217    }
218
219    fn serialize_tuple_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct, Self::Error> {
220        todo!()
221    }
222
223    fn serialize_tuple_variant(self, name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<Self::SerializeTupleVariant, Self::Error> {
224        todo!()
225    }
226
227    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
228        todo!()
229    }
230
231    fn serialize_struct(mut self, name: &'static str, len: usize) -> Result<Self::SerializeStruct, Self::Error> {
232        // eprintln!("{}: {} {}", "serialize struct:".yellow(), name, len);
233        let mut s = SerStruct::new(self.ser, Level::Segment);
234        s.name = name;
235        if is_container_element(name) {
236            s.level = Level::Subelement;
237            s.delimiter = s.ser.formatter.delimiter(s.level);
238            s.skip = true;
239        } else if is_segment(name) {
240            s.level = Level::Element;
241            s.delimiter = s.ser.formatter.delimiter(s.level);
242        }
243        Ok(s)
244    }
245
246    fn serialize_struct_variant(self, name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<Self::SerializeStructVariant, Self::Error> {
247        todo!()
248    }
249
250    fn is_human_readable(&self) -> bool {
251        false
252    }
253}
254
255impl<'ser> ser::SerializeMap for SerState<'ser> {
256    type Ok = ();
257    type Error = X12SerializerError;
258
259    // The Serde data model allows map keys to be any serializable type. JSON
260    // only allows string keys so the implementation below will produce invalid
261    // JSON if the key serializes as something other than a string.
262    //
263    // A real JSON serializer would need to validate that map keys are strings.
264    // This can be done by using a different Serializer to serialize the key
265    // (instead of `&mut **self`) and having that other serializer only
266    // implement `serialize_str` and return an error on any other data type.
267    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
268        where
269            T: ?Sized + Serialize,
270    {
271        todo!()
272    }
273
274    // It doesn't make a difference whether the colon is printed at the end of
275    // `serialize_key` or at the beginning of `serialize_value`. In this case
276    // the code is a bit simpler having it here.
277    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
278        where
279            T: ?Sized + Serialize,
280    {
281        todo!()
282    }
283
284    fn end(self) -> Result<(), Self::Error> {
285        todo!()
286    }
287}
288
289impl<'ser> ser::SerializeStruct for SerStruct<'ser> {
290    type Ok = ();
291    type Error = X12SerializerError;
292
293    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
294        where
295            T: ?Sized + Serialize,
296    {
297        // eprintln!("SerializeStruct({})::serialize_field: {}", self.name, key);
298        if self.skip {
299            self.skip = false;
300            return Ok(());
301        }
302        let size = self.ser.output.len();
303        let r = value.serialize(SerState::new(self.ser, self.level));
304        if self.level != Level::Segment {
305            self.ser.output.push(self.delimiter);
306        }
307        r
308    }
309
310    fn end(self) -> Result<(), Self::Error> {
311        let count = self.ser.output.iter().rev().take_while(|&&c| c == self.delimiter).count();
312        if count > 0 {
313            self.ser.output.truncate(self.ser.output.len() - count + 1);
314        }
315        if self.level != Level::Segment {
316            self.ser.output.pop();
317        }
318        if self.level == Level::Element {
319            let f = self.ser.formatter;
320            let o = &self.ser.output;
321            let ends_segment = o.ends_with(f.visual_separator.as_bytes());
322            if !ends_segment {
323                self.ser.output.push(self.ser.formatter.segment_delimiter);
324                self.ser.output.extend_from_slice(self.ser.formatter.visual_separator.as_bytes());
325            }
326        }
327        // eprintln!("finished {} - {}.\n{}\n{}", self.name, self.level, "colored output:".green(), String::from_utf8(self.ser.output.clone()).unwrap());
328        Ok(())
329    }
330}
331
332impl<'ser> ser::SerializeStructVariant for SerState<'ser> {
333    type Ok = ();
334    type Error = X12SerializerError;
335
336    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
337        where
338            T: ?Sized + Serialize,
339    {
340        todo!()
341    }
342
343    fn end(self) -> Result<(), Self::Error> {
344        todo!()
345    }
346}
347
348impl<'ser> ser::SerializeTupleVariant for SerState<'ser> {
349    type Ok = ();
350    type Error = X12SerializerError;
351
352    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
353        where
354            T: ?Sized + Serialize,
355    {
356        todo!()
357    }
358
359    fn end(self) -> Result<(), Self::Error> {
360        todo!()
361    }
362}
363
364impl<'ser> ser::SerializeTupleStruct for SerState<'ser> {
365    type Ok = ();
366    type Error = X12SerializerError;
367
368    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
369        where
370            T: ?Sized + Serialize,
371    {
372        todo!()
373    }
374
375    fn end(self) -> Result<(), Self::Error> {
376        todo!()
377    }
378}
379
380impl<'ser> ser::SerializeSeq for SerState<'ser> {
381    type Ok = ();
382    type Error = X12SerializerError;
383
384    // Serialize a single element of the sequence.
385    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
386        where
387            T: ?Sized + Serialize,
388    {
389        // eprintln!("{}", self.level);
390        let l = self.level.lower();
391        let r = value.serialize(SerState::new(self.ser, l));
392        // pairs with logic in serialize_none
393        if self.level != Level::Segment {
394            self.ser.output.push(self.delimiter);
395        }
396        r
397    }
398
399    fn end(self) -> Result<(), Self::Error> {
400        if self.level != Level::Segment {
401            self.ser.output.pop();
402        }
403        Ok(())
404    }
405}
406
407impl<'ser> ser::SerializeTuple for SerState<'ser> {
408    type Ok = ();
409    type Error = X12SerializerError;
410
411    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
412        where
413            T: ?Sized + Serialize,
414    {
415        todo!()
416    }
417
418    fn end(self) -> Result<(), Self::Error> {
419        todo!()
420    }
421}
422
423
424#[cfg(test)]
425mod tests {
426    use crate::Element;
427
428    use super::*;
429
430    #[test]
431    fn test_serialize_element_vec() {
432        let value = vec![
433            Element::Value("a".to_string()),
434            Element::Value("b".to_string()),
435            Element::Value("c".to_string()),
436        ];
437        let mut inner = X12Serializer::default();
438        let ser = SerState::new(&mut inner, Level::Element);
439        // let mut ser = X12Serializer::new(X12Formatter::default(), Level::Element);
440        value.serialize(ser).unwrap();
441        assert_eq!(inner.to_string(), "a*b*c");
442    }
443
444    #[test]
445    fn test_serialize_element_vec_with_container() {
446        let value = vec![
447            Element::Value("01".to_string()),
448            Element::Container(vec!["02a".to_string(), "02b".to_string(), "02c".to_string()]),
449            Element::Value("03".to_string()),
450        ];
451        let mut inner = X12Serializer::default();
452        let ser = SerState::new(&mut inner, Level::Element);
453        value.serialize(ser).unwrap();
454        assert_eq!(inner.to_string(), "01*02a:02b:02c*03");
455    }
456
457    #[test]
458    fn test_struct_segment() {
459        #[derive(Serialize, PartialEq, Debug)]
460        struct Segment {
461            field1: String,
462            field2: String,
463            field3: String,
464        }
465        let value = Segment {
466            field1: "01".to_string(),
467            field2: "02".to_string(),
468            field3: "03".to_string(),
469        };
470        let mut inner = X12Serializer::default();
471        let ser = SerState::new(&mut inner, Level::Element);
472        value.serialize(ser).unwrap();
473        assert_eq!(inner.to_string(), "01*02*03~\n");
474    }
475
476    #[test]
477    fn test_single_field_struct_segment_with_container_element() {
478        #[derive(Serialize, PartialEq, Debug)]
479        struct Segment {
480            field2: ContainerElement,
481        }
482        #[derive(Serialize, PartialEq, Debug)]
483        #[serde(tag = "code", rename = "C123")]
484        struct ContainerElement {
485            field1: String,
486            field2: String,
487            field3: String,
488        }
489        let value = Segment {
490            field2: ContainerElement {
491                field1: "02a".to_string(),
492                field2: "02b".to_string(),
493                field3: "02c".to_string(),
494            },
495        };
496        let mut inner = X12Serializer::default();
497        let ser = SerState::new(&mut inner, Level::Element);
498        value.serialize(ser).unwrap();
499        assert_eq!(inner.to_string(), "02a:02b:02c~\n");
500    }
501
502    #[test]
503    fn test_struct_segment_with_container() {
504        #[derive(Serialize, PartialEq, Debug)]
505        struct Segment {
506            field1: String,
507            field2: ContainerElement,
508            field3: String,
509        }
510        #[derive(Serialize, PartialEq, Debug)]
511        #[serde(tag = "code", rename = "C123")]
512        struct ContainerElement {
513            field1: String,
514            field2: String,
515            field3: String,
516        }
517        let value = Segment {
518            field1: "01".to_string(),
519            field2: ContainerElement {
520                field1: "02a".to_string(),
521                field2: "02b".to_string(),
522                field3: "02c".to_string(),
523            },
524            field3: "03".to_string(),
525        };
526        let mut inner = X12Serializer::default();
527        let ser = SerState::new(&mut inner, Level::Element);
528        value.serialize(ser).unwrap();
529        assert_eq!(inner.to_string(), "01*02a:02b:02c*03~\n");
530    }
531}
serde_x12/ser.rs

serde_x12/
ser.rs
