1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
use {primitives, Parcel, Error};
use std::io::prelude::*;
use std;
#[derive(Clone, Debug, PartialEq)]
pub struct DynArray<S: primitives::Integer, T: Parcel>
{
pub elements: Vec<T>,
_a: std::marker::PhantomData<S>,
}
impl<S: primitives::Integer, T: Parcel> DynArray<S,T>
{
pub fn new(elements: Vec<T>) -> Self {
DynArray { elements: elements, _a: std::marker::PhantomData }
}
}
impl<S: primitives::Integer, T: Parcel> Parcel for DynArray<S, T>
{
fn read(read: &mut Read) -> Result<Self, Error> {
let elements = primitives::util::read_list_ext::<S,T>(read)?;
Ok(Self::new(elements))
}
fn write(&self, write: &mut Write) -> Result<(), Error> {
primitives::util::write_list_ext::<S,T,_>(write, self.elements.iter())
}
}
macro_rules! impl_parcel_for_array {
($n:expr) => {
impl<T: Parcel> Parcel for [T; $n] where T: Copy {
fn read(read: &mut Read) -> Result<Self, Error> {
use std::mem;
let mut elements: Vec<T> = Vec::with_capacity($n);
for _ in 0..$n {
let elem = T::read(read)?;
elements.push(elem);
}
let mut array: [T; $n] = unsafe { mem::uninitialized() };
array.clone_from_slice(&elements[..]);
Ok(array)
}
fn write(&self, write: &mut Write) -> Result<(), Error> {
for elem in self.iter() {
elem.write(write)?;
}
Ok(())
}
}
}
}
impl_parcel_for_array!(1);
impl_parcel_for_array!(2);
impl_parcel_for_array!(3);
impl_parcel_for_array!(4);
impl_parcel_for_array!(5);
impl_parcel_for_array!(6);
impl_parcel_for_array!(7);
impl_parcel_for_array!(8);
impl_parcel_for_array!(9);
impl_parcel_for_array!(10);
impl_parcel_for_array!(11);
impl_parcel_for_array!(12);
impl_parcel_for_array!(13);
impl_parcel_for_array!(14);
impl_parcel_for_array!(15);
impl_parcel_for_array!(16);
impl_parcel_for_array!(17);
impl_parcel_for_array!(18);
impl_parcel_for_array!(19);
impl_parcel_for_array!(20);
impl_parcel_for_array!(21);
impl_parcel_for_array!(22);
impl_parcel_for_array!(23);
impl_parcel_for_array!(24);
impl_parcel_for_array!(25);
impl_parcel_for_array!(26);
impl_parcel_for_array!(27);
impl_parcel_for_array!(28);
impl_parcel_for_array!(29);
impl_parcel_for_array!(30);
impl_parcel_for_array!(31);
impl_parcel_for_array!(32);
impl<T: Parcel> Parcel for Vec<T>
{
fn read(read: &mut Read) -> Result<Self, Error> {
primitives::util::read_list(read)
}
fn write(&self, write: &mut Write) -> Result<(), Error> {
primitives::util::write_list(write, self.iter())
}
}
#[cfg(test)]
mod test {
use Parcel;
use std::io::Cursor;
#[test]
fn can_read_array() {
let mut data = Cursor::new([0u8, 1, 2, 3]);
let read_back: [u8; 4] = Parcel::read(&mut data).unwrap();
assert_eq!(read_back, [0, 1, 2, 3]);
}
#[test]
fn can_write_array() {
let mut buffer = Cursor::new(Vec::new());
[5u8, 7, 9, 11].write(&mut buffer).unwrap();
assert_eq!(buffer.into_inner(), vec![5, 7, 9, 11]);
}
}