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

use crate::{BitRead, BitWrite, ByteOrder, Error, Protocol};
use core::any::Any;
use std::convert::TryInto;

impl<T: Protocol + std::fmt::Debug, const N: usize> Protocol for [T; N] {
    fn read(
        read: &mut dyn BitRead,
        byte_order: ByteOrder,
        ctx: &mut dyn Any,
    ) -> Result<Self, Error> {
        let elements = crate::util::read_items(N, read, byte_order, ctx)?;
        Ok(elements.into_iter().collect::<Vec<T>>().try_into().unwrap())
    }

    fn write(
        &self,
        write: &mut dyn BitWrite,
        byte_order: ByteOrder,
        ctx: &mut dyn Any,
    ) -> Result<(), Error> {
        crate::util::write_items(self.iter(), write, byte_order, ctx)
    }
}

#[cfg(test)]
mod test {
    use bitstream_io::{BigEndian, BitReader, BitWriter};

    use crate::{ByteOrder, Protocol};
    use std::io::Cursor;

    #[test]
    fn can_read_array() {
        let mut data = BitReader::endian(Cursor::new([0u8, 1, 2, 3]), BigEndian);
        let read_back: [u8; 4] = Protocol::read(&mut data, ByteOrder::BigEndian, &mut ()).unwrap();
        assert_eq!(read_back, [0, 1, 2, 3]);
    }

    #[test]
    fn can_write_array() {
        let mut data = Vec::new();
        let mut writer = BitWriter::endian(&mut data, BigEndian);

        [5u8, 7, 9, 11]
            .write(&mut writer, ByteOrder::BigEndian, &mut ())
            .unwrap();
        assert_eq!(data, vec![5, 7, 9, 11]);
    }
}