pigeon/
impls.rs

1use super::{
2    pack::{Pack, Result as WriteResult, Target, Writer},
3    unpack::{Reader, Result as ReadResult, Unpack},
4};
5
6macro_rules! impl_for_numeric {
7    ($size:literal, $t:ty) => {
8        impl Pack for $t {
9            fn pack<T: Target>(&self, writer: &mut Writer<T>) -> WriteResult<()> {
10                let bytes = self.to_be_bytes();
11                writer.write_bytes(&bytes[..])
12            }
13        }
14
15        impl<'a> Unpack<'a> for $t {
16            fn unpack(reader: &mut Reader<'a>) -> ReadResult<Self> {
17                let bytes = reader.read_bytes($size)?;
18                let mut buf = [0; $size];
19                bytes.copy_to_slice(&mut buf[..]);
20                Ok(Self::from_be_bytes(buf))
21            }
22        }
23    };
24}
25
26macro_rules! impl_for_numeric_multi {
27    ($(($size:literal, $t:ty),)*) => {
28        $( impl_for_numeric!($size, $t); )*
29    }
30}
31
32macro_rules! impl_for_tuple {
33    ($($v:ident $t:ident),*) => {
34        impl < $($t : Pack),* > Pack for ($($t,)*) {
35            #[allow(unused_parens)]
36            #[allow(unused_variables)]
37            fn pack<T: Target>(&self, writer: &mut Writer<T>) -> WriteResult<()> {
38                let ($($v),*) = self;
39                $(
40                    writer.write($v)?;
41                )*
42                Ok(())
43            }
44        }
45
46        impl < 'a, $($t : Unpack<'a> ),*> Unpack<'a> for ($($t,)*) {
47            #[allow(unused_variables)]
48            fn unpack(reader: &mut Reader<'a>) -> ReadResult<Self> {
49                $(
50                    let $v = reader.read()?;
51                )*
52                Ok(($(
53                    $v
54                ),*))
55            }
56        }
57    }
58}
59
60macro_rules! impl_for_tuple_multi {
61    ($($args:tt,)*) => {
62        $( impl_for_tuple! $args; )*
63    }
64}
65
66impl<'a, A: Pack> Pack for &'a A {
67    fn pack<T: Target>(&self, writer: &mut Writer<T>) -> WriteResult<()> {
68        (**self).pack(writer)
69    }
70}
71
72impl<'a, A: Pack> Pack for &'a mut A {
73    fn pack<T: Target>(&self, writer: &mut Writer<T>) -> WriteResult<()> {
74        (**self).pack(writer)
75    }
76}
77
78impl Pack for bool {
79    fn pack<T: Target>(&self, writer: &mut Writer<T>) -> WriteResult<()> {
80        writer.write_u8_bits(1, if *self { 1u8 } else { 0u8 })
81    }
82}
83
84impl<'a> Unpack<'a> for bool {
85    fn unpack(reader: &mut Reader<'a>) -> ReadResult<Self> {
86        let me: u8 = reader.read_u8_bits(1)?;
87        Ok(me != 0)
88    }
89}
90
91impl_for_numeric_multi! {
92    (1, u8 ),
93    (2, u16),
94    (4, u32),
95    (8, u64),
96    (1, i8 ),
97    (2, i16),
98    (4, i32),
99    (8, i64),
100    (4, f32),
101    (8, f64),
102}
103
104impl_for_tuple_multi! {
105    (),
106    (a A),
107    (a A, b B),
108    (a A, b B, c C),
109    (a A, b B, c C, d D),
110    (a A, b B, c C, d D, e E),
111    (a A, b B, c C, d D, e E, f F),
112    (a A, b B, c C, d D, e E, f F, g G),
113    (a A, b B, c C, d D, e E, f F, g G, h H),
114    (a A, b B, c C, d D, e E, f F, g G, h H, i I),
115    (a A, b B, c C, d D, e E, f F, g G, h H, i I, j J),
116}
pigeon/impls.rs

pigeon/
impls.rs
