dbase/
ser.rs

1use serde::{Serialize, Serializer};
2use std::io::Write;
3
4use crate::field::types::FieldType;
5use crate::writing::FieldWriter;
6use crate::{Date, FieldIOError};
7use crate::{ErrorKind, WritableRecord};
8
9impl<T> WritableRecord for T
10where
11    T: Serialize,
12{
13    fn write_using<'a, W: Write>(
14        &self,
15        field_writer: &mut FieldWriter<'a, W>,
16    ) -> Result<(), FieldIOError> {
17        self.serialize(field_writer)
18    }
19}
20
21impl<'a, W: Write> Serializer for &mut FieldWriter<'a, W> {
22    type Ok = ();
23    type Error = FieldIOError;
24    type SerializeSeq = Self;
25    type SerializeTuple = Self;
26    type SerializeTupleStruct = Self;
27    type SerializeTupleVariant = Self;
28    type SerializeMap = Self;
29    type SerializeStruct = Self;
30    type SerializeStructVariant = Self;
31
32    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
33        self.write_next_field_value(&v)
34    }
35
36    fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
37        unimplemented!("Dbase cannot serialize i8")
38    }
39
40    fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
41        unimplemented!("Dbase cannot serialize i16")
42    }
43
44    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
45        //        let field_info = self.fields_info.next().ok_or(Error::EndOfRecord)?;
46        //        if field_info.field_type == FieldType::Integer {
47        self.write_next_field_value(&v)
48        //        } else {
49        //            Err(Error::IncompatibleType)
50        //        }
51    }
52
53    fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
54        unimplemented!("Dbase cannot serialize i64")
55    }
56
57    fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
58        unimplemented!("Dbase cannot serialize u8")
59    }
60
61    fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
62        unimplemented!("Dbase cannot serialize u16")
63    }
64
65    fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
66        unimplemented!("Dbase cannot serialize u32")
67    }
68
69    fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
70        unimplemented!("Dbase cannot serialize u64")
71    }
72
73    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
74        self.write_next_field_value(&v)
75    }
76
77    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
78        self.write_next_field_value(&v)
79    }
80
81    fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
82        unimplemented!("Dbase cannot serialize char")
83    }
84
85    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
86        self.write_next_field_value(&v)
87    }
88
89    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
90        self.write_next_field_raw(v)
91    }
92
93    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
94        if let Some(field_info) = self.fields_info.peek() {
95            match field_info.field_type {
96                FieldType::Character => self.write_next_field_value::<Option<String>>(&None),
97                FieldType::Numeric => self.write_next_field_value::<Option<f64>>(&None),
98                FieldType::Float => self.write_next_field_value::<Option<f32>>(&None),
99                FieldType::Date => self.write_next_field_value::<Option<Date>>(&None),
100                FieldType::Logical => self.write_next_field_value::<Option<bool>>(&None),
101                _ => Err(FieldIOError::new(
102                    ErrorKind::Message("This field cannot store None values".to_string()),
103                    Some((*field_info).to_owned()),
104                )),
105            }
106        } else {
107            Err(FieldIOError::end_of_record())
108        }
109    }
110
111    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
112    where
113        T: Serialize + ?Sized,
114    {
115        value.serialize(self)
116    }
117
118    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
119        unimplemented!()
120    }
121
122    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
123        unimplemented!("dBase cannot serialize unit struct")
124    }
125
126    fn serialize_unit_variant(
127        self,
128        _name: &'static str,
129        _variant_index: u32,
130        _variant: &'static str,
131    ) -> Result<Self::Ok, Self::Error> {
132        unimplemented!("dBase cannot serialize unit_variant")
133    }
134
135    fn serialize_newtype_struct<T>(
136        self,
137        _name: &'static str,
138        value: &T,
139    ) -> Result<Self::Ok, Self::Error>
140    where
141        T: Serialize + ?Sized,
142    {
143        value.serialize(self)
144    }
145
146    fn serialize_newtype_variant<T>(
147        self,
148        _name: &'static str,
149        _variant_index: u32,
150        _variant: &'static str,
151        _value: &T,
152    ) -> Result<Self::Ok, Self::Error>
153    where
154        T: Serialize + ?Sized,
155    {
156        unimplemented!()
157    }
158
159    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
160        Ok(self as Self::SerializeSeq)
161    }
162
163    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
164        self.serialize_seq(Some(len))
165    }
166
167    fn serialize_tuple_struct(
168        self,
169        _name: &'static str,
170        len: usize,
171    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
172        self.serialize_seq(Some(len))
173    }
174
175    fn serialize_tuple_variant(
176        self,
177        _name: &'static str,
178        _variant_index: u32,
179        _variant: &'static str,
180        _len: usize,
181    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
182        unimplemented!()
183    }
184
185    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
186        unimplemented!()
187    }
188
189    fn serialize_struct(
190        self,
191        _name: &'static str,
192        len: usize,
193    ) -> Result<Self::SerializeStruct, Self::Error> {
194        self.serialize_seq(Some(len))
195    }
196
197    fn serialize_struct_variant(
198        self,
199        _name: &'static str,
200        _variant_index: u32,
201        _variant: &'static str,
202        _len: usize,
203    ) -> Result<Self::SerializeStructVariant, Self::Error> {
204        unimplemented!()
205    }
206
207    fn collect_str<T>(self, _value: &T) -> Result<Self::Ok, Self::Error>
208    where
209        T: std::fmt::Display + ?Sized,
210    {
211        unimplemented!()
212    }
213}
214
215impl<'a, W: Write> serde::ser::SerializeStructVariant for &mut FieldWriter<'a, W> {
216    type Ok = ();
217    type Error = FieldIOError;
218
219    fn serialize_field<T>(&mut self, _key: &'static str, _value: &T) -> Result<(), Self::Error>
220    where
221        T: Serialize + ?Sized,
222    {
223        unimplemented!()
224    }
225
226    fn end(self) -> Result<Self::Ok, Self::Error> {
227        unimplemented!()
228    }
229}
230
231impl<'a, W: Write> serde::ser::SerializeStruct for &mut FieldWriter<'a, W> {
232    type Ok = ();
233    type Error = FieldIOError;
234
235    fn serialize_field<T>(&mut self, _key: &'static str, value: &T) -> Result<(), Self::Error>
236    where
237        T: Serialize + ?Sized,
238    {
239        value.serialize(&mut **self)
240    }
241
242    fn end(self) -> Result<Self::Ok, Self::Error> {
243        Ok(())
244    }
245}
246
247impl<'a, W: Write> serde::ser::SerializeSeq for &mut FieldWriter<'a, W> {
248    type Ok = ();
249    type Error = FieldIOError;
250
251    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
252    where
253        T: Serialize + ?Sized,
254    {
255        value.serialize(&mut **self)
256    }
257
258    fn end(self) -> Result<Self::Ok, Self::Error> {
259        Ok(())
260    }
261}
262
263impl<'a, W: Write> serde::ser::SerializeMap for &mut FieldWriter<'a, W> {
264    type Ok = ();
265    type Error = FieldIOError;
266
267    fn serialize_key<T>(&mut self, _key: &T) -> Result<(), Self::Error>
268    where
269        T: Serialize + ?Sized,
270    {
271        unimplemented!()
272    }
273
274    fn serialize_value<T>(&mut self, _value: &T) -> Result<(), Self::Error>
275    where
276        T: Serialize + ?Sized,
277    {
278        unimplemented!()
279    }
280
281    fn end(self) -> Result<Self::Ok, Self::Error> {
282        unimplemented!()
283    }
284}
285
286impl<'a, W: Write> serde::ser::SerializeTupleVariant for &mut FieldWriter<'a, W> {
287    type Ok = ();
288    type Error = FieldIOError;
289
290    fn serialize_field<T>(&mut self, _value: &T) -> Result<(), Self::Error>
291    where
292        T: Serialize + ?Sized,
293    {
294        unimplemented!()
295    }
296
297    fn end(self) -> Result<Self::Ok, Self::Error> {
298        unimplemented!()
299    }
300}
301
302impl<'a, W: Write> serde::ser::SerializeTupleStruct for &mut FieldWriter<'a, W> {
303    type Ok = ();
304    type Error = FieldIOError;
305
306    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
307    where
308        T: Serialize + ?Sized,
309    {
310        value.serialize(&mut **self)
311    }
312
313    fn end(self) -> Result<Self::Ok, Self::Error> {
314        Ok(())
315    }
316}
317
318impl<'a, W: Write> serde::ser::SerializeTuple for &mut FieldWriter<'a, W> {
319    type Ok = ();
320    type Error = FieldIOError;
321
322    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
323    where
324        T: Serialize + ?Sized,
325    {
326        value.serialize(&mut **self)
327    }
328
329    fn end(self) -> Result<Self::Ok, Self::Error> {
330        Ok(())
331    }
332}
333
334impl serde::ser::Error for FieldIOError {
335    fn custom<T: std::fmt::Display>(msg: T) -> Self {
336        Self {
337            field: None,
338            kind: ErrorKind::Message(msg.to_string()),
339        }
340    }
341}
dbase/ser.rs

dbase/
ser.rs
