barse 0.3.0

Binary parsing library.
Documentation 
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

use std::convert::identity;

use crate::{wrap, ByteRead, FromByteReader, FromByteReaderWith};

impl<'input, T> FromByteReaderWith<'input, wrap::Len> for Vec<T>
where
    T: FromByteReader<'input>,
{
    type Err = T::Err;
    fn from_byte_reader_with<R>(
        mut reader: R,
        wrap::Len(with): wrap::Len,
    ) -> Result<Self, Self::Err>
    where
        R: ByteRead<'input>,
    {
        let mut vec = Vec::with_capacity(with);

        for _ in 0..with {
            vec.push(T::from_byte_reader(&mut reader)?);
        }

        Ok(vec)
    }
}

impl<'input, T, W> FromByteReaderWith<'input, (wrap::Len, W)> for Vec<T>
where
    T: FromByteReaderWith<'input, W>,
    W: Clone,
{
    type Err = T::Err;
    fn from_byte_reader_with<R>(
        mut reader: R,
        (wrap::Len(size), with): (wrap::Len, W),
    ) -> Result<Self, Self::Err>
    where
        R: ByteRead<'input>,
    {
        let mut vec = Vec::with_capacity(size);

        for _ in 0..size {
            vec.push(T::from_byte_reader_with(&mut reader, with.clone())?);
        }

        Ok(vec)
    }
}

impl<'input, 'slice, T, S, W, M> FromByteReaderWith<'input, (&'slice [S], M)> for Vec<T>
where
    T: FromByteReaderWith<'input, W>,
    M: FnMut(&'slice S) -> W,
{
    type Err = T::Err;
    fn from_byte_reader_with<R>(
        mut reader: R,
        (with, mut map): (&'slice [S], M),
    ) -> Result<Self, Self::Err>
    where
        R: ByteRead<'input>,
    {
        let mut vec = Vec::with_capacity(with.len());

        for with in with {
            vec.push(T::from_byte_reader_with(&mut reader, map(with))?);
        }

        Ok(vec)
    }
}

impl<'input, T, I, W, M> FromByteReaderWith<'input, (wrap::Iter<I>, M)> for Vec<T>
where
    T: FromByteReaderWith<'input, W>,
    I: IntoIterator,
    M: FnMut(I::Item) -> W,
{
    type Err = T::Err;

    fn from_byte_reader_with<R>(
        mut reader: R,
        (wrap::Iter(with), mut map): (wrap::Iter<I>, M),
    ) -> Result<Self, Self::Err>
    where
        R: ByteRead<'input>,
    {
        let mut vec = Vec::new();

        for with in with {
            vec.push(T::from_byte_reader_with(&mut reader, map(with))?);
        }

        Ok(vec)
    }
}

impl<'input, T, I> FromByteReaderWith<'input, wrap::Iter<I>> for Vec<T>
where
    T: FromByteReaderWith<'input, I::Item>,
    I: IntoIterator,
{
    type Err = T::Err;
    fn from_byte_reader_with<R>(reader: R, with: wrap::Iter<I>) -> Result<Self, Self::Err>
    where
        R: ByteRead<'input>,
    {
        Vec::from_byte_reader_with(reader, (with, identity))
    }
}

impl<'input, 'w, T, W> FromByteReaderWith<'input, &'w [W]> for Vec<T>
where
    T: FromByteReaderWith<'input, &'w W>,
{
    type Err = T::Err;

    fn from_byte_reader_with<R>(reader: R, with: &'w [W]) -> Result<Self, Self::Err>
    where
        R: ByteRead<'input>,
    {
        Vec::from_byte_reader_with(reader, (with, identity))
    }
}