dust_dds/xtypes/
xcdr_deserializer.rs

1use super::{
2    deserialize::XTypesDeserialize,
3    deserializer::{
4        DeserializeAppendableStruct, DeserializeArray, DeserializeFinalStruct,
5        DeserializeMutableStruct, DeserializeSequence, XTypesDeserializer,
6    },
7    error::XTypesError,
8};
9use core::str;
10
11const PID_SENTINEL: u16 = 1;
12
13pub struct Xcdr1BeDeserializer<'a> {
14    reader: Reader<'a>,
15}
16
17impl<'a> Xcdr1BeDeserializer<'a> {
18    pub fn new(buffer: &'a [u8]) -> Self {
19        Self {
20            reader: Reader::new(buffer),
21        }
22    }
23}
24
25pub struct Xcdr1LeDeserializer<'a> {
26    reader: Reader<'a>,
27}
28
29impl<'a> Xcdr1LeDeserializer<'a> {
30    pub fn new(buffer: &'a [u8]) -> Self {
31        Self {
32            reader: Reader::new(buffer),
33        }
34    }
35}
36
37pub struct Xcdr2BeDeserializer<'a> {
38    reader: Reader<'a>,
39}
40
41impl<'a> Xcdr2BeDeserializer<'a> {
42    pub fn new(buffer: &'a [u8]) -> Self {
43        Self {
44            reader: Reader::new(buffer),
45        }
46    }
47}
48
49pub struct Xcdr2LeDeserializer<'a> {
50    reader: Reader<'a>,
51}
52
53impl<'a> Xcdr2LeDeserializer<'a> {
54    pub fn new(buffer: &'a [u8]) -> Self {
55        Self {
56            reader: Reader::new(buffer),
57        }
58    }
59}
60
61struct Reader<'a> {
62    buffer: &'a [u8],
63    pos: usize,
64}
65
66impl<'a> Reader<'a> {
67    fn new(buffer: &'a [u8]) -> Self {
68        Self { buffer, pos: 0 }
69    }
70    fn buffer(&self) -> &'a [u8] {
71        &self.buffer[self.pos..]
72    }
73    fn read<const N: usize>(&mut self) -> Result<&'a [u8; N], XTypesError> {
74        if self.pos + N > self.buffer.len() {
75            return Err(XTypesError::InvalidData);
76        }
77        let ret = core::convert::TryFrom::try_from(&self.buffer[self.pos..self.pos + N])
78            .expect("length guaranteed");
79        self.pos += N;
80        Ok(ret)
81    }
82    fn read_all(&mut self, length: usize) -> Result<&'a [u8], XTypesError> {
83        if self.pos + length > self.buffer.len() {
84            return Err(XTypesError::InvalidData);
85        }
86        let ret = &self.buffer[self.pos..self.pos + length];
87        self.pos += length;
88        Ok(ret)
89    }
90
91    fn seek(&mut self, v: usize) {
92        self.pos += v
93    }
94
95    fn seek_padding(&mut self, alignment: usize) {
96        let mask = alignment - 1;
97        self.seek(((self.pos + mask) & !mask) - self.pos)
98    }
99}
100
101fn read_with_padding_v1<const N: usize>(reader: &mut Reader) -> Result<[u8; N], XTypesError> {
102    reader.seek_padding(N);
103    reader.read().cloned()
104}
105
106fn read_with_padding_v2<const N: usize>(reader: &mut Reader) -> Result<[u8; N], XTypesError> {
107    reader.seek_padding(core::cmp::min(N, 4));
108    reader.read().cloned()
109}
110
111fn seek_to_pid_be(reader: &mut Reader, pid: u16) -> Result<(), XTypesError> {
112    loop {
113        let current_pid = u16::from_be_bytes(*reader.read()?);
114        let length = u16::from_be_bytes(*reader.read()?) as usize;
115        if current_pid == pid {
116            return Ok(());
117        } else if current_pid == PID_SENTINEL {
118            return Err(XTypesError::PidNotFound(pid));
119        } else {
120            reader.seek(length);
121            reader.seek_padding(4);
122        }
123    }
124}
125
126fn seek_to_pid_le(reader: &mut Reader, pid: u16) -> Result<(), XTypesError> {
127    loop {
128        let current_pid = u16::from_le_bytes(*reader.read()?);
129        let length = u16::from_le_bytes(*reader.read()?) as usize;
130        if current_pid == pid {
131            return Ok(());
132        } else if current_pid == PID_SENTINEL {
133            return Err(XTypesError::PidNotFound(pid));
134        } else {
135            reader.seek(length);
136            reader.seek_padding(4);
137        }
138    }
139}
140
141fn seek_to_optional_pid_be(reader: &mut Reader, pid: u16) -> Result<bool, XTypesError> {
142    loop {
143        let current_pid = u16::from_be_bytes(*reader.read()?);
144        let length = u16::from_be_bytes(*reader.read()?) as usize;
145        if current_pid == pid {
146            return Ok(true);
147        } else if current_pid == PID_SENTINEL {
148            return Ok(false);
149        } else {
150            reader.seek(length);
151            reader.seek_padding(4);
152        }
153    }
154}
155
156fn seek_to_optional_pid_le(reader: &mut Reader, pid: u16) -> Result<bool, XTypesError> {
157    loop {
158        let current_pid = u16::from_le_bytes(*reader.read()?);
159        let length = u16::from_le_bytes(*reader.read()?) as usize;
160        if current_pid == pid {
161            return Ok(true);
162        } else if current_pid == PID_SENTINEL {
163            return Ok(false);
164        } else {
165            reader.seek(length);
166            reader.seek_padding(4);
167        }
168    }
169}
170
171fn into_bool(v: u8) -> Result<bool, XTypesError> {
172    match v {
173        0 => Ok(false),
174        1 => Ok(true),
175        _ => Err(XTypesError::InvalidData),
176    }
177}
178
179struct DelimitedCdrDecoder<'a, D> {
180    deserializer: &'a mut D,
181}
182impl<'de, D> DeserializeAppendableStruct<'de> for DelimitedCdrDecoder<'_, D>
183where
184    for<'a> &'a mut D: XTypesDeserializer<'de>,
185{
186    fn deserialize_field<T: XTypesDeserialize<'de>>(
187        &mut self,
188        _name: &str,
189    ) -> Result<T, XTypesError> {
190        u32::deserialize(&mut *self.deserializer)?;
191        T::deserialize(&mut *self.deserializer)
192    }
193}
194
195struct PlCdrBeDecoder<'a> {
196    buffer: &'a [u8],
197}
198
199impl<'de> DeserializeMutableStruct<'de> for PlCdrBeDecoder<'de> {
200    fn deserialize_field<T: XTypesDeserialize<'de>>(
201        &mut self,
202        pid: u32,
203        _name: &str,
204    ) -> Result<T, XTypesError> {
205        let mut reader = Reader::new(self.buffer);
206        seek_to_pid_be(&mut reader, pid as u16)?;
207        T::deserialize(&mut Xcdr1BeDeserializer { reader })
208    }
209
210    fn deserialize_optional_field<T: XTypesDeserialize<'de>>(
211        &mut self,
212        pid: u32,
213        _name: &str,
214    ) -> Result<Option<T>, XTypesError> {
215        let mut reader = Reader::new(self.buffer);
216        Ok(if seek_to_optional_pid_be(&mut reader, pid as u16)? {
217            Some(T::deserialize(&mut Xcdr1BeDeserializer { reader })?)
218        } else {
219            None
220        })
221    }
222}
223
224struct PlCdrLeDecoder<'a> {
225    buffer: &'a [u8],
226}
227
228impl<'de> DeserializeMutableStruct<'de> for PlCdrLeDecoder<'de> {
229    fn deserialize_field<T: XTypesDeserialize<'de>>(
230        &mut self,
231        pid: u32,
232        _name: &str,
233    ) -> Result<T, XTypesError> {
234        let mut reader = Reader::new(self.buffer);
235        seek_to_pid_le(&mut reader, pid as u16)?;
236        T::deserialize(&mut Xcdr1LeDeserializer { reader })
237    }
238
239    fn deserialize_optional_field<T: XTypesDeserialize<'de>>(
240        &mut self,
241        pid: u32,
242        _name: &str,
243    ) -> Result<Option<T>, XTypesError> {
244        let mut reader = Reader::new(self.buffer);
245        Ok(if seek_to_optional_pid_le(&mut reader, pid as u16)? {
246            Some(T::deserialize(&mut Xcdr1LeDeserializer { reader })?)
247        } else {
248            None
249        })
250    }
251}
252
253struct PlCdr2BeDecoder<'a> {
254    buffer: &'a [u8],
255}
256
257impl<'de> DeserializeMutableStruct<'de> for PlCdr2BeDecoder<'de> {
258    fn deserialize_field<T: XTypesDeserialize<'de>>(
259        &mut self,
260        pid: u32,
261        _name: &str,
262    ) -> Result<T, XTypesError> {
263        let mut reader = Reader::new(self.buffer);
264        seek_to_pid_be(&mut reader, pid as u16)?;
265        T::deserialize(&mut Xcdr2BeDeserializer { reader })
266    }
267
268    fn deserialize_optional_field<T: XTypesDeserialize<'de>>(
269        &mut self,
270        pid: u32,
271        _name: &str,
272    ) -> Result<Option<T>, XTypesError> {
273        let mut reader = Reader::new(self.buffer);
274        Ok(if seek_to_optional_pid_be(&mut reader, pid as u16)? {
275            Some(T::deserialize(&mut Xcdr2BeDeserializer { reader })?)
276        } else {
277            None
278        })
279    }
280}
281
282struct PlCdr2LeDecoder<'a> {
283    buffer: &'a [u8],
284}
285
286impl<'de> DeserializeMutableStruct<'de> for PlCdr2LeDecoder<'de> {
287    fn deserialize_field<T: XTypesDeserialize<'de>>(
288        &mut self,
289        pid: u32,
290        _name: &str,
291    ) -> Result<T, XTypesError> {
292        let mut reader = Reader::new(self.buffer);
293        seek_to_pid_le(&mut reader, pid as u16)?;
294        T::deserialize(&mut Xcdr2LeDeserializer { reader })
295    }
296
297    fn deserialize_optional_field<T: XTypesDeserialize<'de>>(
298        &mut self,
299        pid: u32,
300        _name: &str,
301    ) -> Result<Option<T>, XTypesError> {
302        let mut reader = Reader::new(self.buffer);
303        Ok(if seek_to_optional_pid_le(&mut reader, pid as u16)? {
304            Some(T::deserialize(&mut Xcdr2LeDeserializer { reader })?)
305        } else {
306            None
307        })
308    }
309}
310
311struct ArrayDecoder<'a, D> {
312    deserializer: &'a mut D,
313}
314impl<'de, D> DeserializeArray<'de> for ArrayDecoder<'_, D>
315where
316    for<'a> &'a mut D: XTypesDeserializer<'de>,
317{
318    fn deserialize_element<T: XTypesDeserialize<'de>>(&mut self) -> Result<T, XTypesError> {
319        T::deserialize(&mut *self.deserializer)
320    }
321}
322
323struct SequenceDecoder<'a, D> {
324    deserializer: &'a mut D,
325    len: usize,
326}
327impl<'de, D> DeserializeSequence<'de> for SequenceDecoder<'_, D>
328where
329    for<'a> &'a mut D: XTypesDeserializer<'de>,
330{
331    fn len(&self) -> usize {
332        self.len
333    }
334
335    fn is_empty(&self) -> bool {
336        self.len == 0
337    }
338
339    fn deserialize_element<T: XTypesDeserialize<'de>>(&mut self) -> Result<T, XTypesError> {
340        T::deserialize(&mut *self.deserializer)
341    }
342}
343
344struct PlainCdrBeDecoder<'a, 'de> {
345    deserializer: &'a mut Xcdr1BeDeserializer<'de>,
346}
347impl<'de> DeserializeAppendableStruct<'de> for PlainCdrBeDecoder<'_, 'de> {
348    fn deserialize_field<T: XTypesDeserialize<'de>>(
349        &mut self,
350        _name: &str,
351    ) -> Result<T, XTypesError> {
352        T::deserialize(&mut *self.deserializer)
353    }
354}
355
356impl<'de> DeserializeFinalStruct<'de> for PlainCdrBeDecoder<'_, 'de> {
357    fn deserialize_field<T: XTypesDeserialize<'de>>(
358        &mut self,
359        _name: &str,
360    ) -> Result<T, XTypesError> {
361        T::deserialize(&mut *self.deserializer)
362    }
363
364    fn deserialize_optional_field<T: XTypesDeserialize<'de>>(
365        &mut self,
366        _name: &str,
367    ) -> Result<Option<T>, XTypesError> {
368        self.deserializer.reader.seek_padding(4);
369        let _pid = u16::deserialize(&mut *self.deserializer)?;
370        let length = u16::deserialize(&mut *self.deserializer)?;
371        if length == 0 {
372            Ok(None)
373        } else {
374            Ok(Some(T::deserialize(&mut *self.deserializer)?))
375        }
376    }
377}
378
379struct PlainCdrLeDecoder<'a, 'de> {
380    deserializer: &'a mut Xcdr1LeDeserializer<'de>,
381}
382impl<'de> DeserializeAppendableStruct<'de> for PlainCdrLeDecoder<'_, 'de> {
383    fn deserialize_field<T: XTypesDeserialize<'de>>(
384        &mut self,
385        _name: &str,
386    ) -> Result<T, XTypesError> {
387        T::deserialize(&mut *self.deserializer)
388    }
389}
390
391impl<'de> DeserializeFinalStruct<'de> for PlainCdrLeDecoder<'_, 'de> {
392    fn deserialize_field<T: XTypesDeserialize<'de>>(
393        &mut self,
394        _name: &str,
395    ) -> Result<T, XTypesError> {
396        T::deserialize(&mut *self.deserializer)
397    }
398
399    fn deserialize_optional_field<T: XTypesDeserialize<'de>>(
400        &mut self,
401        _name: &str,
402    ) -> Result<Option<T>, XTypesError> {
403        self.deserializer.reader.seek_padding(4);
404        let _pid = u16::deserialize(&mut *self.deserializer)?;
405        let length = u16::deserialize(&mut *self.deserializer)?;
406        if length == 0 {
407            Ok(None)
408        } else {
409            Ok(Some(T::deserialize(&mut *self.deserializer)?))
410        }
411    }
412}
413
414struct PlainCdr2Decoder<'a, D> {
415    deserializer: &'a mut D,
416}
417impl<'de, D> DeserializeFinalStruct<'de> for PlainCdr2Decoder<'_, D>
418where
419    for<'a> &'a mut D: XTypesDeserializer<'de>,
420{
421    fn deserialize_field<T: XTypesDeserialize<'de>>(
422        &mut self,
423        _name: &str,
424    ) -> Result<T, XTypesError> {
425        T::deserialize(&mut *self.deserializer)
426    }
427
428    fn deserialize_optional_field<T: XTypesDeserialize<'de>>(
429        &mut self,
430        _name: &str,
431    ) -> Result<Option<T>, XTypesError> {
432        if bool::deserialize(&mut *self.deserializer)? {
433            Ok(Some(T::deserialize(&mut *self.deserializer)?))
434        } else {
435            Ok(None)
436        }
437    }
438}
439
440impl<'de> XTypesDeserializer<'de> for &mut Xcdr1BeDeserializer<'de> {
441    fn deserialize_final_struct(self) -> Result<impl DeserializeFinalStruct<'de>, XTypesError> {
442        Ok(PlainCdrBeDecoder { deserializer: self })
443    }
444    fn deserialize_appendable_struct(
445        self,
446    ) -> Result<impl DeserializeAppendableStruct<'de>, XTypesError> {
447        Ok(PlainCdrBeDecoder { deserializer: self })
448    }
449    fn deserialize_mutable_struct(self) -> Result<impl DeserializeMutableStruct<'de>, XTypesError> {
450        Ok(PlCdrBeDecoder {
451            buffer: self.reader.buffer(),
452        })
453    }
454    fn deserialize_array(self) -> Result<impl DeserializeArray<'de>, XTypesError> {
455        Ok(ArrayDecoder { deserializer: self })
456    }
457    fn deserialize_sequence(self) -> Result<impl DeserializeSequence<'de>, XTypesError> {
458        let len = self.deserialize_uint32()? as usize;
459        Ok(SequenceDecoder {
460            deserializer: self,
461            len,
462        })
463    }
464
465    fn deserialize_boolean(self) -> Result<bool, XTypesError> {
466        into_bool(self.deserialize_uint8()?)
467    }
468    fn deserialize_int8(self) -> Result<i8, XTypesError> {
469        Ok(i8::from_be_bytes(read_with_padding_v1(&mut self.reader)?))
470    }
471    fn deserialize_int16(self) -> Result<i16, XTypesError> {
472        Ok(i16::from_be_bytes(read_with_padding_v1(&mut self.reader)?))
473    }
474    fn deserialize_int32(self) -> Result<i32, XTypesError> {
475        Ok(i32::from_be_bytes(read_with_padding_v1(&mut self.reader)?))
476    }
477    fn deserialize_int64(self) -> Result<i64, XTypesError> {
478        Ok(i64::from_be_bytes(read_with_padding_v1(&mut self.reader)?))
479    }
480    fn deserialize_uint8(self) -> Result<u8, XTypesError> {
481        Ok(u8::from_be_bytes(read_with_padding_v1(&mut self.reader)?))
482    }
483    fn deserialize_uint16(self) -> Result<u16, XTypesError> {
484        Ok(u16::from_be_bytes(read_with_padding_v1(&mut self.reader)?))
485    }
486    fn deserialize_uint32(self) -> Result<u32, XTypesError> {
487        Ok(u32::from_be_bytes(read_with_padding_v1(&mut self.reader)?))
488    }
489    fn deserialize_uint64(self) -> Result<u64, XTypesError> {
490        Ok(u64::from_be_bytes(read_with_padding_v1(&mut self.reader)?))
491    }
492    fn deserialize_float32(self) -> Result<f32, XTypesError> {
493        Ok(f32::from_be_bytes(read_with_padding_v1(&mut self.reader)?))
494    }
495    fn deserialize_float64(self) -> Result<f64, XTypesError> {
496        Ok(f64::from_be_bytes(read_with_padding_v1(&mut self.reader)?))
497    }
498    fn deserialize_char8(self) -> Result<char, XTypesError> {
499        Ok(self.deserialize_uint8()? as char)
500    }
501    fn deserialize_string(self) -> Result<&'de str, XTypesError> {
502        str::from_utf8(
503            self.deserialize_byte_sequence()?
504                .split_last()
505                .ok_or(XTypesError::InvalidData)?
506                .1,
507        )
508        .map_err(|_| XTypesError::InvalidData)
509    }
510    fn deserialize_byte_sequence(self) -> Result<&'de [u8], XTypesError> {
511        let length = self.deserialize_uint32()? as usize;
512        self.reader.read_all(length)
513    }
514
515    fn deserialize_byte_array<const N: usize>(self) -> Result<&'de [u8; N], XTypesError> {
516        self.reader.read()
517    }
518}
519
520impl<'de> XTypesDeserializer<'de> for &mut Xcdr1LeDeserializer<'de> {
521    fn deserialize_final_struct(self) -> Result<impl DeserializeFinalStruct<'de>, XTypesError> {
522        Ok(PlainCdrLeDecoder { deserializer: self })
523    }
524    fn deserialize_appendable_struct(
525        self,
526    ) -> Result<impl DeserializeAppendableStruct<'de>, XTypesError> {
527        Ok(PlainCdrLeDecoder { deserializer: self })
528    }
529    fn deserialize_mutable_struct(self) -> Result<impl DeserializeMutableStruct<'de>, XTypesError> {
530        Ok(PlCdrLeDecoder {
531            buffer: self.reader.buffer(),
532        })
533    }
534    fn deserialize_array(self) -> Result<impl DeserializeArray<'de>, XTypesError> {
535        Ok(ArrayDecoder { deserializer: self })
536    }
537    fn deserialize_sequence(self) -> Result<impl DeserializeSequence<'de>, XTypesError> {
538        let len = self.deserialize_uint32()? as usize;
539        Ok(SequenceDecoder {
540            deserializer: self,
541            len,
542        })
543    }
544
545    fn deserialize_boolean(self) -> Result<bool, XTypesError> {
546        into_bool(self.deserialize_uint8()?)
547    }
548    fn deserialize_uint8(self) -> Result<u8, XTypesError> {
549        Ok(u8::from_le_bytes(read_with_padding_v1(&mut self.reader)?))
550    }
551    fn deserialize_uint16(self) -> Result<u16, XTypesError> {
552        Ok(u16::from_le_bytes(read_with_padding_v1(&mut self.reader)?))
553    }
554    fn deserialize_uint32(self) -> Result<u32, XTypesError> {
555        Ok(u32::from_le_bytes(read_with_padding_v1(&mut self.reader)?))
556    }
557    fn deserialize_uint64(self) -> Result<u64, XTypesError> {
558        Ok(u64::from_le_bytes(read_with_padding_v1(&mut self.reader)?))
559    }
560    fn deserialize_int8(self) -> Result<i8, XTypesError> {
561        Ok(i8::from_le_bytes(read_with_padding_v1(&mut self.reader)?))
562    }
563    fn deserialize_int16(self) -> Result<i16, XTypesError> {
564        Ok(i16::from_le_bytes(read_with_padding_v1(&mut self.reader)?))
565    }
566    fn deserialize_int32(self) -> Result<i32, XTypesError> {
567        Ok(i32::from_le_bytes(read_with_padding_v1(&mut self.reader)?))
568    }
569    fn deserialize_int64(self) -> Result<i64, XTypesError> {
570        Ok(i64::from_le_bytes(read_with_padding_v1(&mut self.reader)?))
571    }
572    fn deserialize_float32(self) -> Result<f32, XTypesError> {
573        Ok(f32::from_le_bytes(read_with_padding_v1(&mut self.reader)?))
574    }
575    fn deserialize_float64(self) -> Result<f64, XTypesError> {
576        Ok(f64::from_le_bytes(read_with_padding_v1(&mut self.reader)?))
577    }
578    fn deserialize_char8(self) -> Result<char, XTypesError> {
579        Ok(self.deserialize_uint8()? as char)
580    }
581    fn deserialize_string(self) -> Result<&'de str, XTypesError> {
582        str::from_utf8(
583            self.deserialize_byte_sequence()?
584                .split_last()
585                .ok_or(XTypesError::InvalidData)?
586                .1,
587        )
588        .map_err(|_| XTypesError::InvalidData)
589    }
590    fn deserialize_byte_sequence(self) -> Result<&'de [u8], XTypesError> {
591        let length = self.deserialize_uint32()? as usize;
592        self.reader.read_all(length)
593    }
594    fn deserialize_byte_array<const N: usize>(self) -> Result<&'de [u8; N], XTypesError> {
595        self.reader.read()
596    }
597}
598
599impl<'de> XTypesDeserializer<'de> for &mut Xcdr2BeDeserializer<'de> {
600    fn deserialize_final_struct(self) -> Result<impl DeserializeFinalStruct<'de>, XTypesError> {
601        Ok(PlainCdr2Decoder { deserializer: self })
602    }
603    fn deserialize_appendable_struct(
604        self,
605    ) -> Result<impl DeserializeAppendableStruct<'de>, XTypesError> {
606        Ok(DelimitedCdrDecoder { deserializer: self })
607    }
608    fn deserialize_mutable_struct(self) -> Result<impl DeserializeMutableStruct<'de>, XTypesError> {
609        Ok(PlCdr2BeDecoder {
610            buffer: self.reader.buffer(),
611        })
612    }
613    fn deserialize_array(self) -> Result<impl DeserializeArray<'de>, XTypesError> {
614        Ok(ArrayDecoder { deserializer: self })
615    }
616    fn deserialize_sequence(self) -> Result<impl DeserializeSequence<'de>, XTypesError> {
617        let len = self.deserialize_uint32()? as usize;
618        Ok(SequenceDecoder {
619            deserializer: self,
620            len,
621        })
622    }
623
624    fn deserialize_boolean(self) -> Result<bool, XTypesError> {
625        into_bool(self.deserialize_uint8()?)
626    }
627    fn deserialize_int8(self) -> Result<i8, XTypesError> {
628        Ok(i8::from_be_bytes(read_with_padding_v2(&mut self.reader)?))
629    }
630    fn deserialize_int16(self) -> Result<i16, XTypesError> {
631        Ok(i16::from_be_bytes(read_with_padding_v2(&mut self.reader)?))
632    }
633    fn deserialize_int32(self) -> Result<i32, XTypesError> {
634        Ok(i32::from_be_bytes(read_with_padding_v2(&mut self.reader)?))
635    }
636    fn deserialize_int64(self) -> Result<i64, XTypesError> {
637        Ok(i64::from_be_bytes(read_with_padding_v2(&mut self.reader)?))
638    }
639    fn deserialize_uint8(self) -> Result<u8, XTypesError> {
640        Ok(u8::from_be_bytes(read_with_padding_v2(&mut self.reader)?))
641    }
642    fn deserialize_uint16(self) -> Result<u16, XTypesError> {
643        Ok(u16::from_be_bytes(read_with_padding_v2(&mut self.reader)?))
644    }
645    fn deserialize_uint32(self) -> Result<u32, XTypesError> {
646        Ok(u32::from_be_bytes(read_with_padding_v2(&mut self.reader)?))
647    }
648    fn deserialize_uint64(self) -> Result<u64, XTypesError> {
649        Ok(u64::from_be_bytes(read_with_padding_v2(&mut self.reader)?))
650    }
651    fn deserialize_float32(self) -> Result<f32, XTypesError> {
652        Ok(f32::from_be_bytes(read_with_padding_v2(&mut self.reader)?))
653    }
654    fn deserialize_float64(self) -> Result<f64, XTypesError> {
655        Ok(f64::from_be_bytes(read_with_padding_v2(&mut self.reader)?))
656    }
657    fn deserialize_char8(self) -> Result<char, XTypesError> {
658        Ok(self.deserialize_uint8()? as char)
659    }
660    fn deserialize_string(self) -> Result<&'de str, XTypesError> {
661        str::from_utf8(
662            self.deserialize_byte_sequence()?
663                .split_last()
664                .ok_or(XTypesError::InvalidData)?
665                .1,
666        )
667        .map_err(|_| XTypesError::InvalidData)
668    }
669    fn deserialize_byte_sequence(self) -> Result<&'de [u8], XTypesError> {
670        let length = self.deserialize_uint32()? as usize;
671        self.reader.read_all(length)
672    }
673    fn deserialize_byte_array<const N: usize>(self) -> Result<&'de [u8; N], XTypesError> {
674        self.reader.read()
675    }
676}
677
678impl<'de> XTypesDeserializer<'de> for &mut Xcdr2LeDeserializer<'de> {
679    fn deserialize_final_struct(self) -> Result<impl DeserializeFinalStruct<'de>, XTypesError> {
680        Ok(PlainCdr2Decoder { deserializer: self })
681    }
682    fn deserialize_appendable_struct(
683        self,
684    ) -> Result<impl DeserializeAppendableStruct<'de>, XTypesError> {
685        Ok(DelimitedCdrDecoder {
686            deserializer: &mut *self,
687        })
688    }
689    fn deserialize_mutable_struct(self) -> Result<impl DeserializeMutableStruct<'de>, XTypesError> {
690        Ok(PlCdr2LeDecoder {
691            buffer: self.reader.buffer(),
692        })
693    }
694    fn deserialize_array(self) -> Result<impl DeserializeArray<'de>, XTypesError> {
695        Ok(ArrayDecoder { deserializer: self })
696    }
697    fn deserialize_sequence(self) -> Result<impl DeserializeSequence<'de>, XTypesError> {
698        let len = self.deserialize_uint32()? as usize;
699        Ok(SequenceDecoder {
700            deserializer: self,
701            len,
702        })
703    }
704
705    fn deserialize_boolean(self) -> Result<bool, XTypesError> {
706        into_bool(self.deserialize_uint8()?)
707    }
708    fn deserialize_uint8(self) -> Result<u8, XTypesError> {
709        Ok(u8::from_le_bytes(read_with_padding_v2(&mut self.reader)?))
710    }
711    fn deserialize_uint16(self) -> Result<u16, XTypesError> {
712        Ok(u16::from_le_bytes(read_with_padding_v2(&mut self.reader)?))
713    }
714    fn deserialize_uint32(self) -> Result<u32, XTypesError> {
715        Ok(u32::from_le_bytes(read_with_padding_v2(&mut self.reader)?))
716    }
717    fn deserialize_uint64(self) -> Result<u64, XTypesError> {
718        Ok(u64::from_le_bytes(read_with_padding_v2(&mut self.reader)?))
719    }
720    fn deserialize_int8(self) -> Result<i8, XTypesError> {
721        Ok(i8::from_le_bytes(read_with_padding_v2(&mut self.reader)?))
722    }
723    fn deserialize_int16(self) -> Result<i16, XTypesError> {
724        Ok(i16::from_le_bytes(read_with_padding_v2(&mut self.reader)?))
725    }
726    fn deserialize_int32(self) -> Result<i32, XTypesError> {
727        Ok(i32::from_le_bytes(read_with_padding_v2(&mut self.reader)?))
728    }
729    fn deserialize_int64(self) -> Result<i64, XTypesError> {
730        Ok(i64::from_le_bytes(read_with_padding_v2(&mut self.reader)?))
731    }
732    fn deserialize_float32(self) -> Result<f32, XTypesError> {
733        Ok(f32::from_le_bytes(read_with_padding_v2(&mut self.reader)?))
734    }
735    fn deserialize_float64(self) -> Result<f64, XTypesError> {
736        Ok(f64::from_le_bytes(read_with_padding_v2(&mut self.reader)?))
737    }
738    fn deserialize_char8(self) -> Result<char, XTypesError> {
739        Ok(self.deserialize_uint8()? as char)
740    }
741    fn deserialize_string(self) -> Result<&'de str, XTypesError> {
742        str::from_utf8(
743            self.deserialize_byte_sequence()?
744                .split_last()
745                .ok_or(XTypesError::InvalidData)?
746                .1,
747        )
748        .map_err(|_| XTypesError::InvalidData)
749    }
750    fn deserialize_byte_sequence(self) -> Result<&'de [u8], XTypesError> {
751        let length = self.deserialize_uint32()? as usize;
752        self.reader.read_all(length)
753    }
754    fn deserialize_byte_array<const N: usize>(self) -> Result<&'de [u8; N], XTypesError> {
755        self.reader.read()
756    }
757}
758
759#[cfg(test)]
760mod tests {
761    use crate::xtypes::bytes::Bytes;
762
763    use super::*;
764
765    #[test]
766    fn padding_reader() {
767        let buffer = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
768        let mut reader = Reader::new(buffer);
769        reader.seek(1);
770        reader.seek_padding(4);
771        assert_eq!(reader.pos, 4);
772        let mut reader = Reader::new(buffer);
773        reader.seek(2);
774        reader.seek_padding(4);
775        assert_eq!(reader.pos, 4);
776        let mut reader = Reader::new(buffer);
777        reader.seek(3);
778        reader.seek_padding(4);
779        assert_eq!(reader.pos, 4);
780        let mut reader = Reader::new(buffer);
781        reader.seek(4);
782        reader.seek_padding(4);
783        assert_eq!(reader.pos, 4);
784        let mut reader = Reader::new(buffer);
785        reader.seek(5);
786        reader.seek_padding(4);
787        assert_eq!(reader.pos, 8);
788
789        let mut reader = Reader::new(buffer);
790        reader.seek(1);
791        reader.seek_padding(8);
792        assert_eq!(reader.pos, 8);
793        let mut reader = Reader::new(buffer);
794        reader.seek(2);
795        reader.seek_padding(8);
796        assert_eq!(reader.pos, 8);
797        let mut reader = Reader::new(buffer);
798        reader.seek(7);
799        reader.seek_padding(8);
800        assert_eq!(reader.pos, 8);
801        let mut reader = Reader::new(buffer);
802        reader.seek(8);
803        reader.seek_padding(8);
804        assert_eq!(reader.pos, 8);
805        let mut reader = Reader::new(buffer);
806        reader.seek(9);
807        reader.seek_padding(8);
808        assert_eq!(reader.pos, 16);
809    }
810
811    fn deserialize_v1_be<'de, T: XTypesDeserialize<'de>>(
812        data: &'de [u8],
813    ) -> Result<T, XTypesError> {
814        T::deserialize(&mut Xcdr1BeDeserializer {
815            reader: Reader::new(data),
816        })
817    }
818    fn deserialize_v1_le<'de, T: XTypesDeserialize<'de>>(
819        data: &'de [u8],
820    ) -> Result<T, XTypesError> {
821        T::deserialize(&mut Xcdr1LeDeserializer {
822            reader: Reader::new(data),
823        })
824    }
825    fn deserialize_v2_be<'de, T: XTypesDeserialize<'de>>(
826        data: &'de [u8],
827    ) -> Result<T, XTypesError> {
828        T::deserialize(&mut Xcdr2BeDeserializer {
829            reader: Reader::new(data),
830        })
831    }
832    fn deserialize_v2_le<'de, T: XTypesDeserialize<'de>>(
833        data: &'de [u8],
834    ) -> Result<T, XTypesError> {
835        T::deserialize(&mut Xcdr2LeDeserializer {
836            reader: Reader::new(data),
837        })
838    }
839    #[test]
840    fn deserialize_bool() {
841        let expected = Ok(true);
842        assert_eq!(deserialize_v1_be(&[1]), expected);
843        assert_eq!(deserialize_v1_le(&[1]), expected);
844        assert_eq!(deserialize_v2_be(&[1]), expected);
845        assert_eq!(deserialize_v2_le(&[1]), expected);
846        let expected = Ok(false);
847        assert_eq!(deserialize_v1_be(&[0]), expected);
848        assert_eq!(deserialize_v1_le(&[0]), expected);
849        assert_eq!(deserialize_v2_be(&[0]), expected);
850        assert_eq!(deserialize_v2_le(&[0]), expected);
851        let expected = Err(XTypesError::InvalidData);
852        assert_eq!(deserialize_v1_be::<bool>(&[2]), expected);
853        assert_eq!(deserialize_v1_le::<bool>(&[2]), expected);
854        assert_eq!(deserialize_v2_be::<bool>(&[2]), expected);
855        assert_eq!(deserialize_v2_le::<bool>(&[2]), expected);
856    }
857    #[test]
858    fn deserialize_u8() {
859        let expected = Ok(1_u8);
860        assert_eq!(deserialize_v1_be(&[1]), expected);
861        assert_eq!(deserialize_v1_le(&[1]), expected);
862        assert_eq!(deserialize_v2_be(&[1]), expected);
863        assert_eq!(deserialize_v2_le(&[1]), expected);
864    }
865    #[test]
866    fn deserialize_u16() {
867        let expected = Ok(1_u16);
868        assert_eq!(deserialize_v1_be(&[0, 1]), expected);
869        assert_eq!(deserialize_v1_le(&[1, 0]), expected);
870        assert_eq!(deserialize_v2_be(&[0, 1]), expected);
871        assert_eq!(deserialize_v2_le(&[1, 0]), expected);
872    }
873    #[test]
874    fn deserialize_u32() {
875        let expected = Ok(1_u32);
876        assert_eq!(deserialize_v1_be(&[0, 0, 0, 1]), expected);
877        assert_eq!(deserialize_v1_le(&[1, 0, 0, 0]), expected);
878        assert_eq!(deserialize_v2_be(&[0, 0, 0, 1]), expected);
879        assert_eq!(deserialize_v2_le(&[1, 0, 0, 0]), expected);
880    }
881    #[test]
882    fn deserialize_u64() {
883        let expected = Ok(7_u64);
884        assert_eq!(deserialize_v1_be(&[0, 0, 0, 0, 0, 0, 0, 7,]), expected);
885        assert_eq!(deserialize_v1_le(&[7, 0, 0, 0, 0, 0, 0, 0,]), expected);
886        assert_eq!(deserialize_v2_be(&[0, 0, 0, 0, 0, 0, 0, 7,]), expected);
887        assert_eq!(deserialize_v2_le(&[7, 0, 0, 0, 0, 0, 0, 0,]), expected);
888    }
889    #[test]
890    fn deserialize_i8() {
891        let expected = Ok(1_i8);
892        assert_eq!(deserialize_v1_be(&[1]), expected);
893        assert_eq!(deserialize_v1_le(&[1]), expected);
894        assert_eq!(deserialize_v2_be(&[1]), expected);
895        assert_eq!(deserialize_v2_le(&[1]), expected);
896    }
897    #[test]
898    fn deserialize_i16() {
899        let expected = Ok(1_i16);
900        assert_eq!(deserialize_v1_be(&[0, 1]), expected);
901        assert_eq!(deserialize_v1_le(&[1, 0]), expected);
902        assert_eq!(deserialize_v2_be(&[0, 1]), expected);
903        assert_eq!(deserialize_v2_le(&[1, 0]), expected);
904    }
905    #[test]
906    fn deserialize_i32() {
907        let expected = Ok(1_i32);
908        assert_eq!(deserialize_v1_be(&[0, 0, 0, 1]), expected);
909        assert_eq!(deserialize_v1_le(&[1, 0, 0, 0]), expected);
910        assert_eq!(deserialize_v2_be(&[0, 0, 0, 1]), expected);
911        assert_eq!(deserialize_v2_le(&[1, 0, 0, 0]), expected);
912    }
913    #[test]
914    fn deserialize_i64() {
915        let expected = Ok(7_i64);
916        assert_eq!(deserialize_v1_be(&[0, 0, 0, 0, 0, 0, 0, 7,]), expected);
917        assert_eq!(deserialize_v1_le(&[7, 0, 0, 0, 0, 0, 0, 0,]), expected);
918        assert_eq!(deserialize_v2_be(&[0, 0, 0, 0, 0, 0, 0, 7,]), expected);
919        assert_eq!(deserialize_v2_le(&[7, 0, 0, 0, 0, 0, 0, 0,]), expected);
920    }
921    #[test]
922    fn deserialize_f32() {
923        let expected = Ok(core::f32::MIN_POSITIVE);
924        assert_eq!(deserialize_v1_be(&[0x00, 0x80, 0x00, 0x00]), expected);
925        assert_eq!(deserialize_v1_le(&[0x00, 0x00, 0x80, 0x00]), expected);
926        assert_eq!(deserialize_v2_be(&[0x00, 0x80, 0x00, 0x00]), expected);
927        assert_eq!(deserialize_v2_le(&[0x00, 0x00, 0x80, 0x00]), expected);
928    }
929    #[test]
930    fn deserialize_f64() {
931        let expected = Ok(core::f64::MIN_POSITIVE);
932        assert_eq!(deserialize_v1_be(&[0, 0x10, 0, 0, 0, 0, 0, 0]), expected);
933        assert_eq!(deserialize_v1_le(&[0, 0, 0, 0, 0, 0, 0x10, 0]), expected);
934        assert_eq!(deserialize_v2_be(&[0, 0x10, 0, 0, 0, 0, 0, 0]), expected);
935        assert_eq!(deserialize_v2_le(&[0, 0, 0, 0, 0, 0, 0x10, 0]), expected);
936    }
937    #[test]
938    fn deserialize_char() {
939        let expected = Ok('A');
940        assert_eq!(deserialize_v1_be(&[0x41]), expected);
941        assert_eq!(deserialize_v1_le(&[0x41]), expected);
942        assert_eq!(deserialize_v2_be(&[0x41]), expected);
943        assert_eq!(deserialize_v2_le(&[0x41]), expected);
944    }
945
946    #[test]
947    fn deserialize_string() {
948        let expected = Ok("Hola");
949        assert_eq!(
950            deserialize_v1_be(&[
951                0, 0, 0, 5, //length
952                b'H', b'o', b'l', b'a', // str
953                0x00, // terminating 0
954            ]),
955            expected
956        );
957        assert_eq!(
958            deserialize_v1_le(&[
959                5, 0, 0, 0, //length
960                b'H', b'o', b'l', b'a', // str
961                0x00, // terminating 0
962            ]),
963            expected
964        );
965        assert_eq!(
966            deserialize_v2_be(&[
967                0, 0, 0, 5, //length
968                b'H', b'o', b'l', b'a', // str
969                0x00, // terminating 0
970            ]),
971            expected
972        );
973        assert_eq!(
974            deserialize_v2_le(&[
975                5, 0, 0, 0, //length
976                b'H', b'o', b'l', b'a', // str
977                0x00, // terminating 0
978            ]),
979            expected
980        );
981    }
982
983    #[test]
984    fn deserialize_bytes() {
985        let expected = Ok(&[1u8, 2, 3, 4, 5][..]);
986        assert_eq!(
987            deserialize_v1_be(&[
988                0, 0, 0, 5, // length
989                1, 2, 3, 4, 5 // data
990            ]),
991            expected
992        );
993        assert_eq!(
994            deserialize_v1_le(&[
995                5, 0, 0, 0, // length
996                1, 2, 3, 4, 5 // data
997            ]),
998            expected
999        );
1000        assert_eq!(
1001            deserialize_v2_be(&[
1002                0, 0, 0, 5, // length
1003                1, 2, 3, 4, 5 // data
1004            ]),
1005            expected
1006        );
1007        assert_eq!(
1008            deserialize_v2_le(&[
1009                5, 0, 0, 0, // length
1010                1, 2, 3, 4, 5 // data
1011            ]),
1012            expected
1013        );
1014    }
1015
1016    #[test]
1017    fn deserialize_byte_array() {
1018        let expected = Ok(&[1u8, 2, 3, 4, 5]);
1019        assert_eq!(deserialize_v1_be(&[1, 2, 3, 4, 5, 77]), expected);
1020        assert_eq!(deserialize_v1_le(&[1, 2, 3, 4, 5, 77]), expected);
1021        assert_eq!(deserialize_v2_be(&[1, 2, 3, 4, 5, 77]), expected);
1022        assert_eq!(deserialize_v2_le(&[1, 2, 3, 4, 5, 77]), expected);
1023    }
1024
1025    #[test]
1026    fn deserialize_sequence() {
1027        #[derive(Debug, PartialEq)]
1028        struct Atype(u8);
1029        impl<'de> XTypesDeserialize<'de> for Atype {
1030            fn deserialize(
1031                deserializer: impl XTypesDeserializer<'de>,
1032            ) -> Result<Self, XTypesError> {
1033                Ok(Atype(deserializer.deserialize_uint8()?))
1034            }
1035        }
1036
1037        let expected = Ok([Atype(1), Atype(2)]);
1038        assert_eq!(deserialize_v1_be(&[1, 2, 77]), expected);
1039    }
1040
1041    #[derive(Debug, PartialEq)]
1042    //@extensibility(FINAL)
1043    struct FinalType {
1044        field_u16: u16,
1045        field_u64: u64,
1046    }
1047    impl<'de> XTypesDeserialize<'de> for FinalType {
1048        fn deserialize(deserializer: impl XTypesDeserializer<'de>) -> Result<Self, XTypesError> {
1049            let mut deserializer = deserializer.deserialize_final_struct()?;
1050            Ok(FinalType {
1051                field_u16: deserializer.deserialize_field("field_u16")?,
1052                field_u64: deserializer.deserialize_field("field_u64")?,
1053            })
1054        }
1055    }
1056
1057    #[test]
1058    fn deserialize_final_struct() {
1059        let expected = Ok(FinalType {
1060            field_u16: 7,
1061            field_u64: 9,
1062        });
1063        // PLAIN_CDR:
1064        assert_eq!(
1065            deserialize_v1_be::<FinalType>(&[
1066                0, 7, 0, 0, 0, 0, 0, 0, // field_u16 | padding (6 bytes)
1067                0, 0, 0, 0, 0, 0, 0, 9, // field_u64
1068            ]),
1069            expected
1070        );
1071        assert_eq!(
1072            deserialize_v1_le::<FinalType>(&[
1073                7, 0, 0, 0, 0, 0, 0, 0, // field_u16 | padding (6 bytes)
1074                9, 0, 0, 0, 0, 0, 0, 0, // field_u64
1075            ]),
1076            expected
1077        );
1078        // PLAIN_CDR2:
1079        assert_eq!(
1080            deserialize_v2_be::<FinalType>(&[
1081                0, 7, 0, 0, // field_u16 | padding (2 bytes)
1082                0, 0, 0, 0, 0, 0, 0, 9, // field_u64
1083            ]),
1084            expected
1085        );
1086        assert_eq!(
1087            deserialize_v2_le::<FinalType>(&[
1088                7, 0, 0, 0, // field_u16 | padding (2 bytes)
1089                9, 0, 0, 0, 0, 0, 0, 0, // field_u64
1090            ]),
1091            expected
1092        );
1093    }
1094
1095    #[derive(Debug, PartialEq)]
1096    //@extensibility(FINAL)
1097    struct TypeWithStr<'a> {
1098        field_str: &'a str,
1099        field_u16: u16,
1100        field_slice: Bytes<'a>,
1101    }
1102    impl<'de> XTypesDeserialize<'de> for TypeWithStr<'de> {
1103        fn deserialize(deserializer: impl XTypesDeserializer<'de>) -> Result<Self, XTypesError> {
1104            let mut deserializer = deserializer.deserialize_final_struct()?;
1105            Ok(Self {
1106                field_str: deserializer.deserialize_field("field_str")?,
1107                field_u16: deserializer.deserialize_field("field_u16")?,
1108                field_slice: deserializer.deserialize_field("field_slice")?,
1109            })
1110        }
1111    }
1112
1113    #[test]
1114    fn deserialize_struct_with_str() {
1115        let expected = Ok(TypeWithStr {
1116            field_str: "xt",
1117            field_u16: 9,
1118            field_slice: Bytes(&[10, 11]),
1119        });
1120        // PLAIN_CDR:
1121        assert_eq!(
1122            deserialize_v1_be(&[
1123                0, 0, 0, 3, // field_str: length
1124                b'x', b't', 0, 0, //field_str: data | padding (1 bytes)
1125                0, 9, 0, 0, // field_u16 | padding (2 bytes)
1126                0, 0, 0, 2, // field_slice: length
1127                10, 11, //field_slice: data
1128            ]),
1129            expected
1130        );
1131        assert_eq!(
1132            deserialize_v1_le(&[
1133                3, 0, 0, 0, // field_str: length
1134                b'x', b't', 0, 0, //field_str: data | padding (1 bytes)
1135                9, 0, 0, 0, // field_u16 | padding (2 bytes)
1136                2, 0, 0, 0, // field_slice: length
1137                10, 11, //field_slice: data
1138            ]),
1139            expected
1140        );
1141        // PLAIN_CDR2:
1142        assert_eq!(
1143            deserialize_v2_be(&[
1144                0, 0, 0, 3, // field_str: length
1145                b'x', b't', 0, 0, //field_str: data | padding (1 bytes)
1146                0, 9, 0, 0, // field_u16 | padding (2 bytes)
1147                0, 0, 0, 2, // field_slice: length
1148                10, 11, //field_slice: data
1149            ]),
1150            expected
1151        );
1152        assert_eq!(
1153            deserialize_v2_le(&[
1154                3, 0, 0, 0, // field_str: length
1155                b'x', b't', 0, 0, //field_str: data | padding (1 bytes)
1156                9, 0, 0, 0, // field_u16 | padding (2 bytes)
1157                2, 0, 0, 0, // field_slice: length
1158                10, 11, //field_slice: data
1159            ]),
1160            expected
1161        );
1162    }
1163
1164    #[derive(Debug, PartialEq)]
1165    //@extensibility(FINAL)
1166    struct NestedFinalType {
1167        field_nested: FinalType,
1168        field_u8: u8,
1169    }
1170    impl<'de> XTypesDeserialize<'de> for NestedFinalType {
1171        fn deserialize(deserializer: impl XTypesDeserializer<'de>) -> Result<Self, XTypesError> {
1172            let mut deserializer = deserializer.deserialize_final_struct()?;
1173            Ok(Self {
1174                field_nested: deserializer.deserialize_field("field_nested")?,
1175                field_u8: deserializer.deserialize_field("field_u8")?,
1176            })
1177        }
1178    }
1179
1180    #[derive(Debug, PartialEq)]
1181    //@extensibility(FINAL)
1182    struct FinalOptionalType {
1183        field: u8,
1184        optional_field: Option<u16>,
1185    }
1186
1187    impl<'de> XTypesDeserialize<'de> for FinalOptionalType {
1188        fn deserialize(deserializer: impl XTypesDeserializer<'de>) -> Result<Self, XTypesError> {
1189            let mut d = deserializer.deserialize_final_struct()?;
1190            Ok(Self {
1191                field: d.deserialize_field("field")?,
1192                optional_field: d.deserialize_optional_field("optional_field")?,
1193            })
1194        }
1195    }
1196    #[test]
1197    fn deserialize_final_optional_struct() {
1198        let some = Ok(FinalOptionalType {
1199            field: 6,
1200            optional_field: Some(7),
1201        });
1202        // PLAIN_CDR:
1203        assert_eq!(
1204            deserialize_v1_be(&[
1205                6, 0, 0, 0, // u8 | padding
1206                0, 0, 0, 2, // HEADER (FLAGS+ID | length)
1207                0, 7 // optional_field value
1208            ]),
1209            some
1210        );
1211        assert_eq!(
1212            deserialize_v1_le(&[
1213                6, 0, 0, 0, // u8 | padding
1214                0, 0, 2, 0, // HEADER (FLAGS+ID | length)
1215                7, 0 // optional_field value
1216            ]),
1217            some
1218        );
1219        // PLAIN_CDR2:
1220        assert_eq!(
1221            deserialize_v2_be(&[
1222                6, 1, // u8 | boolean for option
1223                0, 7 // optional_field value
1224            ]),
1225            some
1226        );
1227        assert_eq!(
1228            deserialize_v2_le(&[
1229                6, 1, // u8 | boolean for option
1230                7, 0 // optional_field value
1231            ]),
1232            some
1233        );
1234
1235        let none = Ok(FinalOptionalType {
1236            field: 6,
1237            optional_field: None,
1238        });
1239        // PLAIN_CDR:
1240        assert_eq!(
1241            deserialize_v1_be(&[
1242                6, 0, 0, 0, // u8 | padding
1243                0, 0, 0, 0, // HEADER (FLAGS+ID | length)
1244            ]),
1245            none
1246        );
1247        assert_eq!(
1248            deserialize_v1_le(&[
1249                6, 0, 0, 0, // u8 | padding
1250                0, 0, 0, 0, // HEADER (FLAGS+ID | length)
1251            ]),
1252            none
1253        );
1254        // PLAIN_CDR2:
1255        assert_eq!(
1256            deserialize_v2_be(&[
1257            6, 0, // u8 | boolean for option
1258        ]),
1259            none
1260        );
1261        assert_eq!(
1262            deserialize_v2_le(&[
1263            6, 0, // u8 | boolean for option
1264        ]),
1265            none
1266        );
1267    }
1268
1269    #[test]
1270    fn deserialize_nested_final_struct() {
1271        let expected = Ok(NestedFinalType {
1272            field_nested: FinalType {
1273                field_u16: 7,
1274                field_u64: 9,
1275            },
1276            field_u8: 10,
1277        });
1278        // PLAIN_CDR:
1279        assert_eq!(
1280            deserialize_v1_be::<NestedFinalType>(&[
1281                0, 7, 0, 0, 0, 0, 0, 0, // nested FinalType (u16) | padding (6 bytes)
1282                0, 0, 0, 0, 0, 0, 0, 9,  // nested FinalType (u64)
1283                10, //u8
1284            ]),
1285            expected
1286        );
1287        assert_eq!(
1288            deserialize_v1_le::<NestedFinalType>(&[
1289                7, 0, 0, 0, 0, 0, 0, 0, // nested FinalType (u16) | padding (6 bytes)
1290                9, 0, 0, 0, 0, 0, 0, 0,  // nested FinalType (u64)
1291                10, //u8
1292            ]),
1293            expected
1294        );
1295        //PLAIN_CDR2:
1296        assert_eq!(
1297            deserialize_v2_le::<NestedFinalType>(&[
1298                7, 0, 0, 0, // nested FinalType (u16) | padding (2 bytes)
1299                9, 0, 0, 0, 0, 0, 0, 0,  // nested FinalType (u64)
1300                10, //u8
1301            ]),
1302            expected
1303        );
1304        assert_eq!(
1305            deserialize_v2_be::<NestedFinalType>(&[
1306                0, 7, 0, 0, // nested FinalType (u16) | padding
1307                0, 0, 0, 0, 0, 0, 0, 9,  // nested FinalType (u64)
1308                10, //u8
1309            ]),
1310            expected
1311        );
1312    }
1313
1314    #[derive(Debug, PartialEq)]
1315    // @extensibility(APPENDABLE) @nested
1316    struct AppendableType {
1317        value: u16,
1318    }
1319    impl<'de> XTypesDeserialize<'de> for AppendableType {
1320        fn deserialize(deserializer: impl XTypesDeserializer<'de>) -> Result<Self, XTypesError> {
1321            let mut deserializer = deserializer.deserialize_appendable_struct()?;
1322            Ok(Self {
1323                value: deserializer.deserialize_field("value")?,
1324            })
1325        }
1326    }
1327
1328    #[test]
1329    fn deserialize_appendable_struct() {
1330        let expected = Ok(AppendableType { value: 7 });
1331        // PLAIN_CDR:
1332        assert_eq!(deserialize_v1_be::<AppendableType>(&[0, 7]), expected);
1333        assert_eq!(deserialize_v1_le::<AppendableType>(&[7, 0]), expected);
1334        // DELIMITED_CDR:
1335        assert_eq!(
1336            deserialize_v2_be::<AppendableType>(&[
1337                0, 0, 0, 2, // DHEADER
1338                0, 7 // value
1339            ]),
1340            expected
1341        );
1342        assert_eq!(
1343            deserialize_v2_le::<AppendableType>(&[
1344                2, 0, 0, 0, // DHEADER
1345                7, 0 // value
1346            ]),
1347            expected
1348        );
1349    }
1350
1351    #[derive(Debug, PartialEq)]
1352    //@extensibility(MUTABLE)
1353    struct MutableType {
1354        // @id(0x005A) @key
1355        key: u8,
1356        // @id(0x0050)
1357        participant_key: u32,
1358    }
1359
1360    impl<'de> XTypesDeserialize<'de> for MutableType {
1361        fn deserialize(deserializer: impl XTypesDeserializer<'de>) -> Result<Self, XTypesError> {
1362            let mut des = deserializer.deserialize_mutable_struct()?;
1363            Ok(Self {
1364                key: des.deserialize_field(0x005A, "key")?,
1365                participant_key: des.deserialize_field(0x0050, "participant_key")?,
1366            })
1367        }
1368    }
1369
1370    #[test]
1371    fn deserialize_mutable_struct() {
1372        let expected = Ok(MutableType {
1373            key: 7,
1374            participant_key: 8,
1375        });
1376        // PL_CDR:
1377        assert_eq!(
1378            deserialize_v1_be::<MutableType>(&[
1379                0x00, 0x05A, 0, 1, // PID | length
1380                7, 0, 0, 0, // key | padding
1381                0x00, 0x050, 0, 4, // PID | length
1382                0, 0, 0, 8, // participant_key
1383                0, 0, 0, 0, // Sentinel
1384            ]),
1385            expected
1386        );
1387        assert_eq!(
1388            deserialize_v1_le::<MutableType>(&[
1389                0x05A, 0x00, 1, 0, // PID | length
1390                7, 0, 0, 0, // key | padding
1391                0x050, 0x00, 4, 0, // PID | length
1392                8, 0, 0, 0, // participant_key
1393                0, 0, 0, 0, // Sentinel
1394            ]),
1395            expected
1396        );
1397        // PL_CDR2:
1398        assert_eq!(
1399            deserialize_v2_be::<MutableType>(&[
1400                0x00, 0x05A, 0, 1, // PID | length
1401                7, 0, 0, 0, // key | padding
1402                0x00, 0x050, 0, 4, // PID | length
1403                0, 0, 0, 8, // participant_key
1404                0, 0, 0, 0, // Sentinel
1405            ]),
1406            expected
1407        );
1408        assert_eq!(
1409            deserialize_v2_le::<MutableType>(&[
1410                0x05A, 0x00, 1, 0, // PID | length
1411                7, 0, 0, 0, // key | padding
1412                0x050, 0x00, 4, 0, // PID | length
1413                8, 0, 0, 0, // participant_key
1414                0, 0, 0, 0, // Sentinel
1415            ]),
1416            expected
1417        );
1418    }
1419
1420    #[derive(Debug, PartialEq)]
1421    struct BasicTypes {
1422        f1: bool,
1423        f2: i8,
1424        f3: i16,
1425        f4: i32,
1426        f5: i64,
1427        f6: u8,
1428        f7: u16,
1429        f8: u32,
1430        f9: u64,
1431        f10: f32,
1432        f11: f64,
1433        f12: char,
1434    }
1435    impl<'de> XTypesDeserialize<'de> for BasicTypes {
1436        fn deserialize(deserializer: impl XTypesDeserializer<'de>) -> Result<Self, XTypesError> {
1437            let mut deserializer = deserializer.deserialize_final_struct()?;
1438            Ok(Self {
1439                f1: deserializer.deserialize_field("f1")?,
1440                f2: deserializer.deserialize_field("f2")?,
1441                f3: deserializer.deserialize_field("f3")?,
1442                f4: deserializer.deserialize_field("f4")?,
1443                f5: deserializer.deserialize_field("f5")?,
1444                f6: deserializer.deserialize_field("f6")?,
1445                f7: deserializer.deserialize_field("f7")?,
1446                f8: deserializer.deserialize_field("f8")?,
1447                f9: deserializer.deserialize_field("f9")?,
1448                f10: deserializer.deserialize_field("f10")?,
1449                f11: deserializer.deserialize_field("f11")?,
1450                f12: deserializer.deserialize_field("f12")?,
1451            })
1452        }
1453    }
1454
1455    #[test]
1456    fn deserialize_basic_types_struct() {
1457        let expected = Ok(BasicTypes {
1458            f1: true,
1459            f2: 2,
1460            f3: 3,
1461            f4: 4,
1462            f5: 5,
1463            f6: 6,
1464            f7: 7,
1465            f8: 8,
1466            f9: 9,
1467            f10: 1.0,
1468            f11: 1.0,
1469            f12: 'a',
1470        });
1471        // PLAIN_CDR:
1472        assert_eq!(
1473            deserialize_v1_be(&[
1474                1, 2, 0, 3, 0, 0, 0, 4, // f1: bool | f2: i8 | f3: i16 | f4: i32
1475                0, 0, 0, 0, 0, 0, 0, 5, // f5: i64
1476                6, 0, 0, 7, 0, 0, 0, 8, // f6: u8 | padding (1 byte) | f7: u16 | f8: u32
1477                0, 0, 0, 0, 0, 0, 0, 9, // f9: u64
1478                0x3F, 0x80, 0x00, 0x00, 0, 0, 0, 0, // f10: f32 | padding (4 bytes)
1479                0x3F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // f11: f64
1480                b'a', // f12: char
1481            ]),
1482            expected
1483        );
1484        assert_eq!(
1485            deserialize_v1_le(&[
1486                1, 2, 3, 0, 4, 0, 0, 0, // f1: bool | f2: i8 | f3: i16 | f4: i32
1487                5, 0, 0, 0, 0, 0, 0, 0, // f5: i64
1488                6, 0, 7, 0, 8, 0, 0, 0, // f6: u8 | padding (1 byte) | f7: u16 | f8: u32
1489                9, 0, 0, 0, 0, 0, 0, 0, // f9: u64
1490                0x00, 0x00, 0x80, 0x3F, 0, 0, 0, 0, // f10: f32 | padding (4 bytes)
1491                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F, // f11: f64
1492                b'a', // f12: char
1493            ]),
1494            expected
1495        );
1496        //PLAIN_CDR2:
1497        assert_eq!(
1498            deserialize_v2_be(&[
1499                1, 2, 0, 3, // f1: bool | f2: i8 | f3: i16
1500                0, 0, 0, 4, // f4: i32
1501                0, 0, 0, 0, // f5-1: i64 
1502                0, 0, 0, 5, // f5-2: i64
1503                6, 0, 0, 7, // f6: u8 | padding (1 byte) | f7: u16 
1504                0, 0, 0, 8, // f8: u32
1505                0, 0, 0, 0, // f9-1: u64
1506                0, 0, 0, 9, // f9-2: u64
1507                0x3F, 0x80, 0x00, 0x00, // f10: f32 
1508                0x3F, 0xF0, 0x00, 0x00, // f11-1: f64
1509                0x00, 0x00, 0x00, 0x00, // f11-2: f64
1510                b'a', // f12: char
1511            ]),
1512            expected
1513        );
1514        assert_eq!(
1515            deserialize_v2_le(&[
1516                1, 2, 3, 0, // f1: bool | f2: i8 | f3: i16
1517                4, 0, 0, 0, // f4: i32
1518                5, 0, 0, 0, // f5-1: i64 
1519                0, 0, 0, 0, // f5-2: i64
1520                6, 0, 7, 0, // f6: u8 | padding (1 byte) | f7: u16 
1521                8, 0, 0, 0, // f8: u32
1522                9, 0, 0, 0, // f9-1: u64
1523                0, 0, 0, 0, // f9-2: u64
1524                0x00, 0x00, 0x80, 0x3F, // f10: f32 
1525                0x00, 0x00, 0x00, 0x00, // f11-1: f64
1526                0x00, 0x00, 0xF0, 0x3F, // f11-2: f64
1527                b'a', // f12: char
1528            ]),
1529            expected
1530        );
1531    }
1532}
dust_dds/xtypes/xcdr_deserializer.rs

dust_dds/xtypes/
xcdr_deserializer.rs
