rseip_core/codec/encode/
impls.rs

1// rseip
2//
3// rseip - Ethernet/IP (CIP) in pure Rust.
4// Copyright: 2021, Joylei <leingliu@gmail.com>
5// License: MIT
6
7#![allow(non_snake_case)]
8
9use super::*;
10use alloc::{rc::Rc, sync::Arc};
11use bytes::{BufMut, Bytes, BytesMut};
12use core::marker::PhantomData;
13use smallvec::SmallVec;
14
15impl<A: Encoder> Encoder for &mut A {
16    type Error = A::Error;
17
18    #[inline]
19    fn encode_bool(&mut self, item: bool, buf: &mut BytesMut) -> Result<(), Self::Error> {
20        (**self).encode_bool(item, buf)
21    }
22
23    #[inline]
24    fn encode_i8(&mut self, item: i8, buf: &mut BytesMut) -> Result<(), Self::Error> {
25        (**self).encode_i8(item, buf)
26    }
27
28    #[inline]
29    fn encode_u8(&mut self, item: u8, buf: &mut BytesMut) -> Result<(), Self::Error> {
30        (**self).encode_u8(item, buf)
31    }
32
33    #[inline]
34    fn encode_i16(&mut self, item: i16, buf: &mut BytesMut) -> Result<(), Self::Error> {
35        (**self).encode_i16(item, buf)
36    }
37
38    #[inline]
39    fn encode_u16(&mut self, item: u16, buf: &mut BytesMut) -> Result<(), Self::Error> {
40        (**self).encode_u16(item, buf)
41    }
42
43    #[inline]
44    fn encode_i32(&mut self, item: i32, buf: &mut BytesMut) -> Result<(), Self::Error> {
45        (**self).encode_i32(item, buf)
46    }
47
48    #[inline]
49    fn encode_u32(&mut self, item: u32, buf: &mut BytesMut) -> Result<(), Self::Error> {
50        (**self).encode_u32(item, buf)
51    }
52
53    #[inline]
54    fn encode_i64(&mut self, item: i64, buf: &mut BytesMut) -> Result<(), Self::Error> {
55        (**self).encode_i64(item, buf)
56    }
57
58    #[inline]
59    fn encode_u64(&mut self, item: u64, buf: &mut BytesMut) -> Result<(), Self::Error> {
60        (**self).encode_u64(item, buf)
61    }
62
63    #[inline]
64    fn encode_f32(&mut self, item: f32, buf: &mut BytesMut) -> Result<(), Self::Error> {
65        (**self).encode_f32(item, buf)
66    }
67
68    #[inline]
69    fn encode_f64(&mut self, item: f64, buf: &mut BytesMut) -> Result<(), Self::Error> {
70        (**self).encode_f64(item, buf)
71    }
72
73    #[inline]
74    fn encode_i128(&mut self, item: i128, buf: &mut BytesMut) -> Result<(), Self::Error> {
75        (**self).encode_i128(item, buf)
76    }
77
78    #[inline]
79    fn encode_u128(&mut self, item: u128, buf: &mut BytesMut) -> Result<(), Self::Error> {
80        (**self).encode_u128(item, buf)
81    }
82}
83
84macro_rules! impl_primitive {
85    ($ty:ident, $m:tt, $s:tt) => {
86        impl Encode for $ty {
87            #[inline]
88            fn encode<A: Encoder>(self, buf: &mut BytesMut, encoder: &mut A) -> Result<(), A::Error>
89            where
90                Self: Sized,
91            {
92                encoder.$m(self, buf)
93            }
94
95            #[inline]
96            fn encode_by_ref<A: Encoder>(
97                &self,
98                buf: &mut BytesMut,
99                encoder: &mut A,
100            ) -> Result<(), A::Error> {
101                encoder.$m(*self, buf)
102            }
103
104            #[inline(always)]
105            fn bytes_count(&self) -> usize {
106                $s
107            }
108        }
109    };
110}
111
112impl_primitive!(bool, encode_bool, 1);
113impl_primitive!(i8, encode_i8, 1);
114impl_primitive!(u8, encode_u8, 1);
115impl_primitive!(i16, encode_i16, 2);
116impl_primitive!(u16, encode_u16, 2);
117impl_primitive!(i32, encode_i32, 4);
118impl_primitive!(u32, encode_u32, 4);
119impl_primitive!(i64, encode_i64, 8);
120impl_primitive!(u64, encode_u64, 8);
121impl_primitive!(f32, encode_f32, 4);
122impl_primitive!(f64, encode_f64, 8);
123impl_primitive!(i128, encode_i128, 16);
124impl_primitive!(u128, encode_u128, 16);
125
126impl<T: Encode> Encode for &T {
127    #[inline]
128    fn encode<A: Encoder>(self, buf: &mut BytesMut, encoder: &mut A) -> Result<(), A::Error>
129    where
130        Self: Sized,
131    {
132        self.encode_by_ref(buf, encoder)
133    }
134
135    #[inline]
136    fn encode_by_ref<A: Encoder>(&self, buf: &mut BytesMut, encoder: &mut A) -> Result<(), A::Error>
137    where
138        Self: Sized,
139    {
140        (**self).encode_by_ref(buf, encoder)
141    }
142
143    #[inline]
144    fn bytes_count(&self) -> usize {
145        (**self).bytes_count()
146    }
147}
148
149impl Encode for () {
150    #[inline]
151    fn encode_by_ref<A: Encoder>(
152        &self,
153        _buf: &mut BytesMut,
154        _encoder: &mut A,
155    ) -> Result<(), A::Error>
156    where
157        Self: Sized,
158    {
159        Ok(())
160    }
161
162    #[inline(always)]
163    fn bytes_count(&self) -> usize {
164        0
165    }
166}
167
168impl<T: Encode> Encode for PhantomData<T> {
169    #[inline]
170    fn encode_by_ref<A: Encoder>(
171        &self,
172        _buf: &mut BytesMut,
173        _encoder: &mut A,
174    ) -> Result<(), A::Error>
175    where
176        Self: Sized,
177    {
178        Ok(())
179    }
180
181    #[inline(always)]
182    fn bytes_count(&self) -> usize {
183        0
184    }
185}
186
187impl<T: Encode> Encode for Option<T> {
188    #[inline]
189    fn encode<A: Encoder>(self, buf: &mut BytesMut, encoder: &mut A) -> Result<(), A::Error>
190    where
191        Self: Sized,
192    {
193        if let Some(item) = self {
194            item.encode(buf, encoder)?;
195        }
196        Ok(())
197    }
198
199    #[inline]
200    fn encode_by_ref<A: Encoder>(&self, buf: &mut BytesMut, encoder: &mut A) -> Result<(), A::Error>
201    where
202        Self: Sized,
203    {
204        if let Some(item) = self {
205            item.encode_by_ref(buf, encoder)?;
206        }
207        Ok(())
208    }
209
210    #[inline]
211    fn bytes_count(&self) -> usize {
212        self.as_ref().map(|v| v.bytes_count()).unwrap_or_default()
213    }
214}
215
216impl<T: Encode, const N: usize> Encode for [T; N] {
217    #[inline]
218    fn encode<A: Encoder>(self, buf: &mut BytesMut, encoder: &mut A) -> Result<(), A::Error>
219    where
220        Self: Sized,
221    {
222        for item in self {
223            item.encode(buf, encoder)?;
224        }
225        Ok(())
226    }
227
228    #[inline]
229    fn encode_by_ref<A: Encoder>(&self, buf: &mut BytesMut, encoder: &mut A) -> Result<(), A::Error>
230    where
231        Self: Sized,
232    {
233        for item in self {
234            item.encode_by_ref(buf, encoder)?;
235        }
236        Ok(())
237    }
238
239    #[inline]
240    fn bytes_count(&self) -> usize {
241        self.iter().map(|v| v.bytes_count()).sum()
242    }
243}
244
245impl<T> Encode for SmallVec<T>
246where
247    T: smallvec::Array,
248    T::Item: Encode,
249{
250    #[inline]
251    fn encode<A: Encoder>(self, buf: &mut BytesMut, encoder: &mut A) -> Result<(), A::Error>
252    where
253        Self: Sized,
254    {
255        for item in self {
256            item.encode(buf, encoder)?;
257        }
258        Ok(())
259    }
260
261    #[inline]
262    fn encode_by_ref<A: Encoder>(&self, buf: &mut BytesMut, encoder: &mut A) -> Result<(), A::Error>
263    where
264        Self: Sized,
265    {
266        for item in self {
267            item.encode_by_ref(buf, encoder)?;
268        }
269        Ok(())
270    }
271
272    #[inline]
273    fn bytes_count(&self) -> usize {
274        self.iter().map(|v| v.bytes_count()).sum()
275    }
276}
277
278impl<T: Encode> Encode for Vec<T> {
279    #[inline]
280    fn encode<A: Encoder>(self, buf: &mut BytesMut, encoder: &mut A) -> Result<(), A::Error>
281    where
282        Self: Sized,
283    {
284        for item in self {
285            item.encode(buf, encoder)?;
286        }
287        Ok(())
288    }
289
290    #[inline]
291    fn encode_by_ref<A: Encoder>(&self, buf: &mut BytesMut, encoder: &mut A) -> Result<(), A::Error>
292    where
293        Self: Sized,
294    {
295        for item in self {
296            item.encode_by_ref(buf, encoder)?;
297        }
298        Ok(())
299    }
300
301    #[inline]
302    fn bytes_count(&self) -> usize {
303        self.iter().map(|v| v.bytes_count()).sum()
304    }
305}
306
307impl Encode for Bytes {
308    #[inline]
309    fn encode_by_ref<A: Encoder>(
310        &self,
311        buf: &mut BytesMut,
312        _encoder: &mut A,
313    ) -> Result<(), A::Error> {
314        buf.put_slice(self);
315        Ok(())
316    }
317
318    #[inline]
319    fn bytes_count(&self) -> usize {
320        self.len()
321    }
322}
323
324impl Encode for &[u8] {
325    #[inline]
326    fn encode_by_ref<A: Encoder>(
327        &self,
328        buf: &mut BytesMut,
329        _encoder: &mut A,
330    ) -> Result<(), A::Error> {
331        buf.put_slice(self);
332        Ok(())
333    }
334
335    #[inline]
336    fn bytes_count(&self) -> usize {
337        self.len()
338    }
339}
340
341macro_rules! impl_tuple {
342    ($($n:tt $name:ident)+) => {
343        impl<$($name,)+> Encode for ($($name,)+)
344        where
345            $($name:Encode,)+
346        {
347            #[inline]
348            fn encode<A: Encoder>(self, buf: &mut BytesMut, encoder: &mut A) -> Result<(), A::Error>
349            where
350                Self: Sized,
351            {
352                $(
353                    self.$n.encode(buf, encoder)?;
354                )+
355                Ok(())
356            }
357
358            #[inline]
359            fn encode_by_ref<A: Encoder>(
360                &self,
361                buf: &mut BytesMut,
362                encoder: &mut A,
363            ) -> Result<(), A::Error>
364            where
365                Self: Sized,
366            {
367                $(
368                    self.$n.encode_by_ref(buf, encoder)?;
369                )+
370                Ok(())
371            }
372
373            #[inline]
374            fn bytes_count(&self) -> usize {
375                let mut count = 0;
376                $(
377                    count += self.$n.bytes_count();
378                )+
379                count
380            }
381        }
382    };
383}
384
385//  -- Arc --
386impl<T: Encode> Encode for Arc<T> {
387    #[inline]
388    fn encode_by_ref<A: Encoder>(
389        &self,
390        buf: &mut BytesMut,
391        encoder: &mut A,
392    ) -> Result<(), A::Error> {
393        T::encode_by_ref(self, buf, encoder)
394    }
395    #[inline]
396    fn bytes_count(&self) -> usize {
397        T::bytes_count(self)
398    }
399}
400
401//  -- Rc --
402impl<T: Encode> Encode for Rc<T> {
403    #[inline]
404    fn encode_by_ref<A: Encoder>(
405        &self,
406        buf: &mut BytesMut,
407        encoder: &mut A,
408    ) -> Result<(), A::Error> {
409        T::encode_by_ref(self, buf, encoder)
410    }
411    #[inline]
412    fn bytes_count(&self) -> usize {
413        T::bytes_count(self)
414    }
415}
416
417// -- tuples --
418
419impl_tuple!(0 T0);
420impl_tuple!(0 T0 1 T1);
421impl_tuple!(0 T0 1 T1 2 T2);
422impl_tuple!(0 T0 1 T1 2 T2 3 T3);
423impl_tuple!(0 T0 1 T1 2 T2 3 T3 4 T4);
424impl_tuple!(0 T0 1 T1 2 T2 3 T3 4 T4 5 T5);
425impl_tuple!(0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6);
426impl_tuple!(0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7);
427impl_tuple!(0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8);
428impl_tuple!(0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9);
429impl_tuple!(0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10);
430impl_tuple!(0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11);
431impl_tuple!(0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12);
432impl_tuple!(0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13);
433impl_tuple!(0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14);
434impl_tuple!(0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14 15 T15);
rseip_core/codec/encode/impls.rs

rseip_core/codec/encode/
impls.rs
