dbase/
de.rs

1use std::fmt::Display;
2use std::io::{Read, Seek};
3
4use serde::de::{DeserializeOwned, DeserializeSeed, IntoDeserializer, SeqAccess, Visitor};
5use serde::Deserializer;
6
7use crate::{
8    ErrorKind, FieldConversionError, FieldIOError, FieldIterator, FieldValue, ReadableRecord,
9};
10
11impl<'de, 'a, 'f, R1, R2> SeqAccess<'de> for &mut FieldIterator<'a, R1, R2>
12where
13    R1: Read + Seek,
14    R2: Read + Seek,
15{
16    type Error = FieldIOError;
17
18    fn next_element_seed<T>(
19        &mut self,
20        seed: T,
21    ) -> Result<Option<<T as DeserializeSeed<'de>>::Value>, Self::Error>
22    where
23        T: DeserializeSeed<'de>,
24    {
25        if self.fields_info.peek().is_none() {
26            Ok(None)
27        } else {
28            seed.deserialize(&mut **self).map(Some)
29        }
30    }
31}
32
33//TODO maybe we can deserialize numbers other than f32 & f64 by converting using TryFrom
34impl<'de, 'a, 'f, T, R> Deserializer<'de> for &mut FieldIterator<'a, T, R>
35where
36    T: Read + Seek,
37    R: Read + Seek,
38{
39    type Error = FieldIOError;
40
41    fn deserialize_any<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
42    where
43        V: Visitor<'de>,
44    {
45        Err(FieldConversionError::IncompatibleType.into())
46    }
47
48    fn deserialize_bool<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
49    where
50        V: Visitor<'de>,
51    {
52        let value = self.read_next_field_as::<bool>()?.value;
53        visitor.visit_bool(value)
54    }
55
56    fn deserialize_i8<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
57    where
58        V: Visitor<'de>,
59    {
60        let value = self.read_next_field_as::<i32>()?.value;
61        visitor.visit_i8(
62            value
63                .try_into()
64                .ok()
65                .ok_or(FieldConversionError::IncompatibleType)?,
66        )
67    }
68
69    fn deserialize_i16<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
70    where
71        V: Visitor<'de>,
72    {
73        let value = self.read_next_field_as::<i32>()?.value;
74        visitor.visit_i16(
75            value
76                .try_into()
77                .ok()
78                .ok_or(FieldConversionError::IncompatibleType)?,
79        )
80    }
81
82    fn deserialize_i32<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
83    where
84        V: Visitor<'de>,
85    {
86        let value = self.read_next_field_as::<i32>()?.value;
87        visitor.visit_i32(value)
88    }
89
90    fn deserialize_i64<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
91    where
92        V: Visitor<'de>,
93    {
94        let value = self.read_next_field_as::<i32>()?.value;
95        visitor.visit_i64(value.into())
96    }
97
98    fn deserialize_u8<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
99    where
100        V: Visitor<'de>,
101    {
102        let value = self.read_next_field_as::<i32>()?.value;
103        visitor.visit_u8(
104            value
105                .try_into()
106                .ok()
107                .ok_or(FieldConversionError::IncompatibleType)?,
108        )
109    }
110
111    fn deserialize_u16<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
112    where
113        V: Visitor<'de>,
114    {
115        unimplemented!("DBase cannot deserialize u16")
116    }
117
118    fn deserialize_u32<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
119    where
120        V: Visitor<'de>,
121    {
122        unimplemented!("DBase cannot deserialize u32")
123    }
124
125    fn deserialize_u64<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
126    where
127        V: Visitor<'de>,
128    {
129        unimplemented!("DBase cannot deserialize u64")
130    }
131
132    fn deserialize_f32<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
133    where
134        V: Visitor<'de>,
135    {
136        let value = self.read_next_field_as::<f32>()?.value;
137        visitor.visit_f32(value)
138    }
139
140    fn deserialize_f64<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
141    where
142        V: Visitor<'de>,
143    {
144        let value = self.read_next_field_as::<f64>()?.value;
145        visitor.visit_f64(value)
146    }
147
148    fn deserialize_char<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
149    where
150        V: Visitor<'de>,
151    {
152        unimplemented!("DBase cannot deserialize char")
153    }
154
155    fn deserialize_str<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
156    where
157        V: Visitor<'de>,
158    {
159        unimplemented!("DBase cannot deserialize str")
160    }
161
162    fn deserialize_string<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
163    where
164        V: Visitor<'de>,
165    {
166        let value = self.read_next_field_as::<String>()?.value;
167        visitor.visit_string(value)
168    }
169
170    fn deserialize_bytes<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
171    where
172        V: Visitor<'de>,
173    {
174        unimplemented!("DBase cannot deserialize bytes")
175    }
176
177    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
178    where
179        V: Visitor<'de>,
180    {
181        let value = self.read_next_field_raw()?;
182        visitor.visit_byte_buf(value)
183    }
184
185    fn deserialize_option<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
186    where
187        V: Visitor<'de>,
188    {
189        //FIXME this is actually terrible, this means we read the field twice
190        // Would just peeking the first few bytes and checking they are not padding bytes be better ?
191        let value: FieldValue = self.peek_next_field()?.value;
192        match value {
193            FieldValue::Character(Some(_)) => visitor.visit_some(self),
194            FieldValue::Logical(Some(_)) => visitor.visit_some(self),
195            FieldValue::Numeric(Some(_)) => visitor.visit_some(self),
196            FieldValue::Float(Some(_)) => visitor.visit_some(self),
197            FieldValue::Date(Some(_)) => visitor.visit_some(self),
198            FieldValue::Character(None) => {
199                self.skip_next_field()?;
200                visitor.visit_none()
201            }
202            FieldValue::Logical(None) => {
203                self.skip_next_field()?;
204                visitor.visit_none()
205            }
206            FieldValue::Numeric(None) => {
207                self.skip_next_field()?;
208                visitor.visit_none()
209            }
210            FieldValue::Float(None) => {
211                self.skip_next_field()?;
212                visitor.visit_none()
213            }
214            FieldValue::Date(None) => {
215                self.skip_next_field()?;
216                visitor.visit_none()
217            }
218            _ => visitor.visit_some(self),
219        }
220    }
221
222    fn deserialize_unit<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
223    where
224        V: Visitor<'de>,
225    {
226        unimplemented!("DBase cannot deserialize unit")
227    }
228
229    fn deserialize_unit_struct<V>(
230        self,
231        _name: &'static str,
232        _visitor: V,
233    ) -> Result<<V as Visitor<'de>>::Value, Self::Error>
234    where
235        V: Visitor<'de>,
236    {
237        unimplemented!("DBase cannot deserialize unit struct")
238    }
239
240    fn deserialize_newtype_struct<V>(
241        self,
242        _name: &'static str,
243        visitor: V,
244    ) -> Result<<V as Visitor<'de>>::Value, Self::Error>
245    where
246        V: Visitor<'de>,
247    {
248        visitor.visit_seq(self)
249    }
250
251    fn deserialize_seq<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
252    where
253        V: Visitor<'de>,
254    {
255        unimplemented!("dBase cannot deserialize sequence")
256    }
257
258    fn deserialize_tuple<V>(
259        self,
260        _len: usize,
261        visitor: V,
262    ) -> Result<<V as Visitor<'de>>::Value, Self::Error>
263    where
264        V: Visitor<'de>,
265    {
266        visitor.visit_seq(self)
267    }
268
269    fn deserialize_tuple_struct<V>(
270        self,
271        _name: &'static str,
272        _len: usize,
273        visitor: V,
274    ) -> Result<<V as Visitor<'de>>::Value, Self::Error>
275    where
276        V: Visitor<'de>,
277    {
278        visitor.visit_seq(self)
279    }
280
281    fn deserialize_map<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value, Self::Error>
282    where
283        V: Visitor<'de>,
284    {
285        unimplemented!("DBase cannot deserialize map")
286    }
287
288    fn deserialize_struct<V>(
289        self,
290        _name: &'static str,
291        _fields: &'static [&'static str],
292        visitor: V,
293    ) -> Result<<V as Visitor<'de>>::Value, Self::Error>
294    where
295        V: Visitor<'de>,
296    {
297        visitor.visit_seq(self)
298    }
299
300    fn deserialize_enum<V>(
301        self,
302        _name: &'static str,
303        _variants: &'static [&'static str],
304        visitor: V,
305    ) -> Result<<V as Visitor<'de>>::Value, Self::Error>
306    where
307        V: Visitor<'de>,
308    {
309        let value = self.read_next_field_as::<String>()?.value;
310        visitor.visit_enum(value.into_deserializer())
311    }
312
313    fn deserialize_identifier<V>(
314        self,
315        _visitor: V,
316    ) -> Result<<V as Visitor<'de>>::Value, Self::Error>
317    where
318        V: Visitor<'de>,
319    {
320        unimplemented!("DBase cannot deserialize identifiers")
321    }
322
323    fn deserialize_ignored_any<V>(
324        self,
325        _visitor: V,
326    ) -> Result<<V as Visitor<'de>>::Value, Self::Error>
327    where
328        V: Visitor<'de>,
329    {
330        unimplemented!("DBase cannot deserialize ignored any")
331    }
332}
333
334impl<S: DeserializeOwned> ReadableRecord for S {
335    fn read_using<T, R>(field_iterator: &mut FieldIterator<T, R>) -> Result<Self, FieldIOError>
336    where
337        T: Read + Seek,
338        R: Read + Seek,
339    {
340        S::deserialize(field_iterator)
341    }
342}
343
344impl serde::de::Error for FieldIOError {
345    fn custom<T: Display>(msg: T) -> Self {
346        Self {
347            field: None,
348            kind: ErrorKind::Message(msg.to_string()),
349        }
350    }
351}
dbase/de.rs

dbase/
de.rs
