1pub mod error;
2
3pub mod cdr;
4pub mod delimited_cdr;
5pub mod ffi;
6pub mod plain_cdr;
7pub mod plain_cdr2;
8pub mod plcdr;
9pub mod plcdr2;
10pub mod xcdr2;
11pub mod xcdr_plcdr;
12
13mod utils;
14
15use error::{XcdrError, XcdrResult};
16use std::collections::BTreeMap;
17
18pub struct FieldId(pub u32);
19
20#[derive(Debug, Clone, Copy, PartialEq, Eq)]
21pub enum SerializeKind {
22 Cdr,
23 PlainCdr,
24 PlCdr,
25 PlainCdr2,
26 DelimitedCdr,
27 PlCdr2,
28}
29
30#[allow(unused_variables)]
31pub trait XcdrSerializer {
32 fn begin_struct(&mut self) -> XcdrResult<()> {
33 Ok(())
34 }
35 fn begin_struct_with_kind(&mut self, _kind: SerializeKind) -> XcdrResult<()> {
36 self.begin_struct()
37 }
38 fn end_struct(&mut self) -> XcdrResult<()> {
39 Ok(())
40 }
41
42 fn begin_field(
43 &mut self,
44 id: FieldId,
45 must_understand: bool,
46 length_code: u8,
47 ) -> XcdrResult<()> {
48 Ok(())
49 }
50 fn end_field(&mut self) -> XcdrResult<()> {
51 Ok(())
52 }
53
54 fn write_bool(&mut self, val: bool) -> XcdrResult<()>;
55 fn write_u8(&mut self, val: u8) -> XcdrResult<()>;
56 fn write_i8(&mut self, val: i8) -> XcdrResult<()>;
57 fn write_u16(&mut self, val: u16) -> XcdrResult<()>;
58 fn write_i16(&mut self, val: i16) -> XcdrResult<()>;
59 fn write_u32(&mut self, val: u32) -> XcdrResult<()>;
60 fn write_i32(&mut self, val: i32) -> XcdrResult<()>;
61 fn write_u64(&mut self, val: u64) -> XcdrResult<()>;
62 fn write_i64(&mut self, val: i64) -> XcdrResult<()>;
63 fn write_f32(&mut self, val: f32) -> XcdrResult<()>;
64 fn write_f64(&mut self, val: f64) -> XcdrResult<()>;
65 fn write_bytes(&mut self, buf: &[u8]) -> XcdrResult<()>;
66
67 fn write<T: XcdrSerialize>(&mut self, value: &T) -> XcdrResult<()> {
68 value.serialize_with(self)
69 }
70}
71
72pub trait XcdrDeserializer {
73 fn next_field(&mut self) -> XcdrResult<Option<FieldId>> {
74 Ok(None)
75 }
76 fn enter_struct(&mut self) -> XcdrResult<()> {
77 Ok(())
78 }
79 fn exit_struct(&mut self) -> XcdrResult<()> {
80 Ok(())
81 }
82 fn skip_field(&mut self) -> XcdrResult<()> {
83 Ok(())
84 }
85
86 fn read_u8(&mut self) -> XcdrResult<u8>;
87 fn read_i8(&mut self) -> XcdrResult<i8>;
88 fn read_bool(&mut self) -> XcdrResult<bool>;
89 fn read_u16_le(&mut self) -> XcdrResult<u16>;
90 fn read_u16_be(&mut self) -> XcdrResult<u16>;
91 fn read_i16_le(&mut self) -> XcdrResult<i16>;
92 fn read_i16_be(&mut self) -> XcdrResult<i16>;
93 fn read_u32_le(&mut self) -> XcdrResult<u32>;
94 fn read_u32_be(&mut self) -> XcdrResult<u32>;
95 fn read_i32_le(&mut self) -> XcdrResult<i32>;
96 fn read_i32_be(&mut self) -> XcdrResult<i32>;
97 fn read_u64_le(&mut self) -> XcdrResult<u64>;
98 fn read_u64_be(&mut self) -> XcdrResult<u64>;
99 fn read_i64_le(&mut self) -> XcdrResult<i64>;
100 fn read_i64_be(&mut self) -> XcdrResult<i64>;
101 fn read_f32_le(&mut self) -> XcdrResult<f32>;
102 fn read_f32_be(&mut self) -> XcdrResult<f32>;
103 fn read_f64_le(&mut self) -> XcdrResult<f64>;
104 fn read_f64_be(&mut self) -> XcdrResult<f64>;
105 fn read_bytes(&mut self, out: &mut [u8]) -> XcdrResult<()>;
106
107 fn read<T: XcdrDeserialize>(&mut self) -> XcdrResult<T> {
108 T::deserialize(self)
109 }
110}
111
112pub trait XcdrSerialize {
113 fn serialize_kind(&self) -> SerializeKind {
114 SerializeKind::Cdr
115 }
116
117 fn serialize_with<S: XcdrSerializer + ?Sized>(&self, serializer: &mut S) -> XcdrResult<()>;
118
119 fn serialize(&self, buf: &mut [u8]) -> XcdrResult<usize>
120 where
121 Self: Sized,
122 {
123 serialize_with_kind(self, self.serialize_kind(), buf)
124 }
125}
126
127pub trait XcdrDeserialize: Sized {
128 fn deserialize<D: XcdrDeserializer + ?Sized>(deserializer: &mut D) -> XcdrResult<Self>;
129}
130
131impl XcdrSerialize for bool {
132 fn serialize_with<S: XcdrSerializer + ?Sized>(&self, serializer: &mut S) -> XcdrResult<()> {
133 serializer.write_bool(*self)
134 }
135}
136
137impl XcdrDeserialize for bool {
138 fn deserialize<D: XcdrDeserializer + ?Sized>(deserializer: &mut D) -> XcdrResult<Self> {
139 deserializer.read_bool()
140 }
141}
142
143macro_rules! impl_xcdr_for_int {
144 ($ty:ty, $write:ident, $read:ident) => {
145 impl XcdrSerialize for $ty {
146 fn serialize_with<S: XcdrSerializer + ?Sized>(
147 &self,
148 serializer: &mut S,
149 ) -> XcdrResult<()> {
150 serializer.$write(*self)
151 }
152 }
153
154 impl XcdrDeserialize for $ty {
155 fn deserialize<D: XcdrDeserializer + ?Sized>(deserializer: &mut D) -> XcdrResult<Self> {
156 deserializer.$read()
157 }
158 }
159 };
160}
161
162impl_xcdr_for_int!(u8, write_u8, read_u8);
163impl_xcdr_for_int!(i8, write_i8, read_i8);
164impl_xcdr_for_int!(u16, write_u16, read_u16_le);
165impl_xcdr_for_int!(i16, write_i16, read_i16_le);
166impl_xcdr_for_int!(u32, write_u32, read_u32_le);
167impl_xcdr_for_int!(i32, write_i32, read_i32_le);
168impl_xcdr_for_int!(u64, write_u64, read_u64_le);
169impl_xcdr_for_int!(i64, write_i64, read_i64_le);
170
171impl XcdrSerialize for f32 {
172 fn serialize_with<S: XcdrSerializer + ?Sized>(&self, serializer: &mut S) -> XcdrResult<()> {
173 serializer.write_f32(*self)
174 }
175}
176
177impl XcdrDeserialize for f32 {
178 fn deserialize<D: XcdrDeserializer + ?Sized>(deserializer: &mut D) -> XcdrResult<Self> {
179 deserializer.read_f32_le()
180 }
181}
182
183impl XcdrSerialize for f64 {
184 fn serialize_with<S: XcdrSerializer + ?Sized>(&self, serializer: &mut S) -> XcdrResult<()> {
185 serializer.write_f64(*self)
186 }
187}
188
189impl XcdrDeserialize for f64 {
190 fn deserialize<D: XcdrDeserializer + ?Sized>(deserializer: &mut D) -> XcdrResult<Self> {
191 deserializer.read_f64_le()
192 }
193}
194
195impl XcdrSerialize for char {
196 fn serialize_with<S: XcdrSerializer + ?Sized>(&self, serializer: &mut S) -> XcdrResult<()> {
197 serializer.write_u32(*self as u32)
198 }
199}
200
201impl XcdrDeserialize for char {
202 fn deserialize<D: XcdrDeserializer + ?Sized>(deserializer: &mut D) -> XcdrResult<Self> {
203 let value = deserializer.read_u32_le()?;
204 char::from_u32(value).ok_or_else(|| XcdrError::Message("invalid char value".to_string()))
205 }
206}
207
208impl<T: XcdrSerialize> XcdrSerialize for Box<T> {
209 fn serialize_with<S: XcdrSerializer + ?Sized>(&self, serializer: &mut S) -> XcdrResult<()> {
210 self.as_ref().serialize_with(serializer)
211 }
212}
213
214impl<T: XcdrDeserialize> XcdrDeserialize for Box<T> {
215 fn deserialize<D: XcdrDeserializer + ?Sized>(deserializer: &mut D) -> XcdrResult<Self> {
216 Ok(Box::new(T::deserialize(deserializer)?))
217 }
218}
219
220impl<T: XcdrSerialize, const N: usize> XcdrSerialize for [T; N] {
221 fn serialize_with<S: XcdrSerializer + ?Sized>(&self, serializer: &mut S) -> XcdrResult<()> {
222 for item in self {
223 item.serialize_with(serializer)?;
224 }
225 Ok(())
226 }
227}
228
229impl<T: XcdrDeserialize, const N: usize> XcdrDeserialize for [T; N] {
230 fn deserialize<D: XcdrDeserializer + ?Sized>(deserializer: &mut D) -> XcdrResult<Self> {
231 let mut data = std::mem::MaybeUninit::<[T; N]>::uninit();
232 let ptr = data.as_mut_ptr() as *mut T;
233 for idx in 0..N {
234 unsafe {
235 ptr.add(idx).write(T::deserialize(deserializer)?);
236 }
237 }
238 Ok(unsafe { data.assume_init() })
239 }
240}
241
242impl XcdrSerialize for String {
243 fn serialize_with<S: XcdrSerializer + ?Sized>(&self, serializer: &mut S) -> XcdrResult<()> {
244 let bytes = self.as_bytes();
245 let len = bytes.len().saturating_add(1);
246 if len > u32::MAX as usize {
247 return Err(XcdrError::Message("String too large".to_string()));
248 }
249 serializer.write_u32(len as u32)?;
250 serializer.write_bytes(bytes)?;
251 serializer.write_u8(0)?;
252 Ok(())
253 }
254}
255
256impl XcdrDeserialize for String {
257 fn deserialize<D: XcdrDeserializer + ?Sized>(deserializer: &mut D) -> XcdrResult<Self> {
258 let len = deserializer.read_u32_le()? as usize;
259 if len == 0 {
260 return Ok(String::new());
261 }
262 let mut buf = vec![0u8; len];
263 deserializer.read_bytes(&mut buf)?;
264 if let Some(last) = buf.last()
265 && *last == 0
266 {
267 buf.pop();
268 }
269 String::from_utf8(buf).map_err(|err| XcdrError::Message(err.to_string()))
270 }
271}
272
273impl<T: XcdrSerialize> XcdrSerialize for Vec<T> {
274 fn serialize_with<S: XcdrSerializer + ?Sized>(&self, serializer: &mut S) -> XcdrResult<()> {
275 if self.len() > u32::MAX as usize {
276 return Err(XcdrError::Message("Sequence too large".to_string()));
277 }
278 serializer.write_u32(self.len() as u32)?;
279 for item in self {
280 item.serialize_with(serializer)?;
281 }
282 Ok(())
283 }
284}
285
286impl<T: XcdrDeserialize> XcdrDeserialize for Vec<T> {
287 fn deserialize<D: XcdrDeserializer + ?Sized>(deserializer: &mut D) -> XcdrResult<Self> {
288 let len = deserializer.read_u32_le()? as usize;
289 let mut out = Vec::with_capacity(len);
290 for _ in 0..len {
291 out.push(T::deserialize(deserializer)?);
292 }
293 Ok(out)
294 }
295}
296
297impl<K: XcdrSerialize, V: XcdrSerialize> XcdrSerialize for BTreeMap<K, V> {
298 fn serialize_with<S: XcdrSerializer + ?Sized>(&self, serializer: &mut S) -> XcdrResult<()> {
299 if self.len() > u32::MAX as usize {
300 return Err(XcdrError::Message("Map too large".to_string()));
301 }
302 serializer.write_u32(self.len() as u32)?;
303 for (key, value) in self {
304 key.serialize_with(serializer)?;
305 value.serialize_with(serializer)?;
306 }
307 Ok(())
308 }
309}
310
311fn serialize_with_kind<T: XcdrSerialize + ?Sized>(
312 value: &T,
313 kind: SerializeKind,
314 buf: &mut [u8],
315) -> XcdrResult<usize> {
316 match kind {
317 SerializeKind::Cdr => {
318 let mut serializer = cdr::CdrSerialize::new(buf.as_mut_ptr(), buf.len());
319 value.serialize_with(&mut serializer)?;
320 Ok(serializer.pos)
321 }
322 SerializeKind::PlainCdr => {
323 let mut serializer = plain_cdr::PlainCdrSerialize::new(buf.as_mut_ptr(), buf.len());
324 value.serialize_with(&mut serializer)?;
325 Ok(serializer.pos)
326 }
327 SerializeKind::PlCdr => {
328 let mut serializer = plcdr::PlcdrSerialize::new(buf.as_mut_ptr(), buf.len());
329 value.serialize_with(&mut serializer)?;
330 Ok(serializer.pos)
331 }
332 SerializeKind::PlainCdr2 => {
333 let mut serializer = plain_cdr2::PlainCdr2Serialize::new(buf.as_mut_ptr(), buf.len());
334 value.serialize_with(&mut serializer)?;
335 Ok(serializer.pos)
336 }
337 SerializeKind::DelimitedCdr => {
338 let mut serializer =
339 delimited_cdr::DelimitedCdrSerialize::new(buf.as_mut_ptr(), buf.len());
340 value.serialize_with(&mut serializer)?;
341 Ok(serializer.pos)
342 }
343 SerializeKind::PlCdr2 => {
344 let mut serializer = plcdr2::Plcdr2Serialize::new(buf.as_mut_ptr(), buf.len());
345 value.serialize_with(&mut serializer)?;
346 Ok(serializer.pos)
347 }
348 }
349}
350
351impl<K: XcdrDeserialize + Ord, V: XcdrDeserialize> XcdrDeserialize for BTreeMap<K, V> {
352 fn deserialize<D: XcdrDeserializer + ?Sized>(deserializer: &mut D) -> XcdrResult<Self> {
353 let len = deserializer.read_u32_le()? as usize;
354 let mut out = BTreeMap::new();
355 for _ in 0..len {
356 let key = K::deserialize(deserializer)?;
357 let value = V::deserialize(deserializer)?;
358 out.insert(key, value);
359 }
360 Ok(out)
361 }
362}