Skip to main content

rustorb_cdr/
traits.rs

1use crate::{Decoder, Encoder, LongDouble, Result};
2
3/// A type that can be written as CDR.
4///
5/// [`Vec<T>`] and `[T]` are written as an IDL `sequence` (with a length);
6/// `[T; N]` is written as an IDL array (without a length).
7pub trait CdrEncode {
8    /// Writes `self`.
9    fn encode(&self, enc: &mut Encoder) -> Result<()>;
10
11    /// Writes the elements of a slice, without a length. Overridden for
12    /// `u8` to copy the bytes in one go.
13    fn encode_slice(items: &[Self], enc: &mut Encoder) -> Result<()>
14    where
15        Self: Sized,
16    {
17        items.iter().try_for_each(|item| item.encode(enc))
18    }
19}
20
21/// A type that can be read from CDR.
22pub trait CdrDecode: Sized {
23    /// Reads a value.
24    fn decode(dec: &mut Decoder<'_>) -> Result<Self>;
25
26    /// Reads `len` elements. Overridden for `u8` to copy the bytes in one go.
27    fn decode_vec(len: usize, dec: &mut Decoder<'_>) -> Result<Vec<Self>> {
28        // Cap the up-front allocation; the length was only checked against
29        // a minimum element size of one byte.
30        let mut items = Vec::with_capacity(len.min(4096));
31        for _ in 0..len {
32            items.push(Self::decode(dec)?);
33        }
34        Ok(items)
35    }
36}
37
38macro_rules! impl_number {
39    ($($ty:ty => $write:ident, $read:ident;)*) => {
40        $(
41            impl CdrEncode for $ty {
42                fn encode(&self, enc: &mut Encoder) -> Result<()> {
43                    enc.$write(*self);
44                    Ok(())
45                }
46            }
47
48            impl CdrDecode for $ty {
49                fn decode(dec: &mut Decoder<'_>) -> Result<Self> {
50                    dec.$read()
51                }
52            }
53        )*
54    };
55}
56
57impl_number! {
58    bool => write_bool, read_bool;
59    i16 => write_i16, read_i16;
60    u16 => write_u16, read_u16;
61    i32 => write_i32, read_i32;
62    u32 => write_u32, read_u32;
63    i64 => write_i64, read_i64;
64    u64 => write_u64, read_u64;
65    f32 => write_f32, read_f32;
66    f64 => write_f64, read_f64;
67    LongDouble => write_long_double, read_long_double;
68}
69
70impl CdrEncode for u8 {
71    fn encode(&self, enc: &mut Encoder) -> Result<()> {
72        enc.write_octet(*self);
73        Ok(())
74    }
75
76    fn encode_slice(items: &[Self], enc: &mut Encoder) -> Result<()> {
77        enc.write_octets(items);
78        Ok(())
79    }
80}
81
82impl CdrDecode for u8 {
83    fn decode(dec: &mut Decoder<'_>) -> Result<Self> {
84        dec.read_octet()
85    }
86
87    fn decode_vec(len: usize, dec: &mut Decoder<'_>) -> Result<Vec<Self>> {
88        Ok(dec.read_octets(len)?.to_vec())
89    }
90}
91
92/// IDL4 `int8`, an octet-sized signed integer.
93impl CdrEncode for i8 {
94    fn encode(&self, enc: &mut Encoder) -> Result<()> {
95        enc.write_octet(*self as u8);
96        Ok(())
97    }
98}
99
100impl CdrDecode for i8 {
101    fn decode(dec: &mut Decoder<'_>) -> Result<Self> {
102        Ok(dec.read_octet()? as i8)
103    }
104}
105
106impl CdrEncode for str {
107    fn encode(&self, enc: &mut Encoder) -> Result<()> {
108        enc.write_string(self)
109    }
110}
111
112impl CdrEncode for String {
113    fn encode(&self, enc: &mut Encoder) -> Result<()> {
114        enc.write_string(self)
115    }
116}
117
118impl CdrDecode for String {
119    fn decode(dec: &mut Decoder<'_>) -> Result<Self> {
120        dec.read_string()
121    }
122}
123
124impl<T: CdrEncode> CdrEncode for [T] {
125    fn encode(&self, enc: &mut Encoder) -> Result<()> {
126        enc.write_len(self.len())?;
127        T::encode_slice(self, enc)
128    }
129}
130
131impl<T: CdrEncode> CdrEncode for Vec<T> {
132    fn encode(&self, enc: &mut Encoder) -> Result<()> {
133        self.as_slice().encode(enc)
134    }
135}
136
137impl<T: CdrDecode> CdrDecode for Vec<T> {
138    fn decode(dec: &mut Decoder<'_>) -> Result<Self> {
139        let len = dec.read_len(1)?;
140        T::decode_vec(len, dec)
141    }
142}
143
144impl<T: CdrEncode, const N: usize> CdrEncode for [T; N] {
145    fn encode(&self, enc: &mut Encoder) -> Result<()> {
146        T::encode_slice(self, enc)
147    }
148}
149
150impl<T: CdrDecode, const N: usize> CdrDecode for [T; N] {
151    fn decode(dec: &mut Decoder<'_>) -> Result<Self> {
152        let items = T::decode_vec(N, dec)?;
153        Ok(items
154            .try_into()
155            .unwrap_or_else(|_| unreachable!("decode_vec returned N items")))
156    }
157}
158
159impl<T: CdrEncode + ?Sized> CdrEncode for &T {
160    fn encode(&self, enc: &mut Encoder) -> Result<()> {
161        (**self).encode(enc)
162    }
163}
164
165impl<T: CdrEncode + ?Sized> CdrEncode for Box<T> {
166    fn encode(&self, enc: &mut Encoder) -> Result<()> {
167        (**self).encode(enc)
168    }
169}
170
171impl<T: CdrDecode> CdrDecode for Box<T> {
172    fn decode(dec: &mut Decoder<'_>) -> Result<Self> {
173        T::decode(dec).map(Box::new)
174    }
175}