jppe/
input.rs

1#[cfg(not(feature = "std"))]
2use alloc::{
3    vec::Vec,
4};
5use crate::{ByteOrder, JResult};
6use crate::errors::{make_error, ErrorKind};
7
8
9pub trait InputTrait<'a> {
10    fn find_subsequence<'b>(&self, needle: &'b [u8], is_save_needle: bool) -> JResult<&'a [u8], &'a [u8]>;
11
12    fn find_subsequences<'b>(&self, needles: &'b [&'b [u8]], is_save_needle: bool) -> JResult<&'a [u8], &'a [u8]>;
13
14    fn find_subsequences2<'b>(&self, needles: &'b Vec<Vec<u8>>, is_save_needle: bool) -> JResult<&'a [u8], &'a [u8]>;
15
16    fn input_take(&self, length: usize) -> JResult<&'a [u8], &'a [u8]>;
17
18    fn to_bits(&self, byteorder: ByteOrder, byte_count: u8) -> JResult<&'a [u8], u128>;
19
20    fn to_le_bits(&self, byte_count: u8) -> JResult<&'a [u8], u128>;
21
22    fn to_be_bits(&self, byte_count: u8) -> JResult<&'a [u8], u128>;
23
24    #[inline]
25    fn to_bits_usize(&self, byteorder: ByteOrder, byte_count: u8) -> JResult<&'a [u8], usize> {
26        let (input, value) = self.to_bits(byteorder, byte_count)?;
27        Ok((input, value as usize))
28    }
29
30    #[inline]
31    fn to_le_bits_usize(&self, byte_count: u8) -> JResult<&'a [u8], usize> {
32        let (input, value) = self.to_le_bits(byte_count)?;
33        Ok((input, value as usize))
34    }
35
36    #[inline]
37    fn to_be_bits_usize(&self, byte_count: u8) -> JResult<&'a [u8], usize> {
38        let (input, value) = self.to_be_bits(byte_count)?;
39        Ok((input, value as usize))
40    }
41}
42
43
44impl<'a> InputTrait<'a> for &'a [u8] {
45    // #[inline]
46    fn find_subsequence<'b>(&self, needle: &'b [u8], is_save_needle: bool) -> JResult<&'a [u8], &'a [u8]> {
47        let input = *self;
48        let needle_len = needle.len();
49        let input_len = input.len();
50    
51        if needle_len > input_len {
52            return Err(make_error(input, ErrorKind::InvalidByteLength { offset: input_len }));
53        }
54    
55        // if let Some(index) = input
56        //     .windows(needle_len)
57        //     .position(|window| window == needle)
58        //     // && let Some(value) = input.take(..index + needle_len)
59        // {
60        //     return Ok((&input[index + needle_len..], if is_save_needle {&input[..index + needle_len]} else {&input[..index]}));
61        // }
62
63        for i in 0..input_len {
64            let mut status = false;
65    
66            for j in 0..needle_len {
67                if needle[j] != input[i + j] {
68                    status = true;
69                    break;
70                }
71            }
72    
73            if !status {
74                return Ok((&input[i + needle_len..], if is_save_needle {&input[..i + needle_len]} else {&input[..i]}));
75            }
76        }
77
78        Err(make_error(input, ErrorKind::InvalidByteLength { offset: 0 }))
79    }
80
81    fn find_subsequences<'b>(&self, needles: &'b [&'b [u8]], is_save_needle: bool) -> JResult<&'a [u8], &'a [u8]> {
82        let input = *self;
83        let input_len = input.len();
84
85        for needle in needles {
86            if let Ok((input, value)) = self.find_subsequence(needle, is_save_needle) {
87                return Ok((input, value));
88            }
89        }
90    
91        Err(make_error(input, ErrorKind::SubSequence { offset: input_len }))      
92    }
93
94    fn find_subsequences2<'b>(&self, needles: &'b Vec<Vec<u8>>, is_save_needle: bool) -> JResult<&'a [u8], &'a [u8]> {
95        let input = *self;
96        let input_len = input.len();
97
98        for needle in needles {
99            if let Ok((input, value)) = self.find_subsequence(needle, is_save_needle) {
100                return Ok((input, value));
101            }
102        }
103    
104        Err(make_error(input, ErrorKind::SubSequence { offset: input_len }))      
105    }
106
107    #[inline]
108    fn input_take(&self, length: usize) -> JResult<&'a [u8], &'a [u8]> {
109        let input = *self;
110
111        if length <= input.len() {
112            return Ok((&input[length..], &input[..length]));
113        }    
114    
115        Err(make_error(input, ErrorKind::InvalidByteLength { offset: input.len() }))
116    }
117
118    fn to_bits(&self, byteorder: ByteOrder, byte_count: u8) -> JResult<&'a [u8], u128> {
119        let input = *self;
120        let input_len = input.len();
121        let mut value: u128 = 0;
122    
123        if input_len < byte_count.into() {
124            return Err(make_error(input, ErrorKind::InvalidByteLength { offset: input_len }));
125        }
126    
127        match byteorder {
128            ByteOrder::Be => {
129                for byte in input.iter().take(byte_count.into()) {
130                    value = (value << 8) + *byte as u128;
131                }
132            },
133            ByteOrder::Le => {
134                for (index, byte) in input.iter().enumerate().take(byte_count.into()) {
135                    value += (*byte as u128) << (8 * index);
136                }
137            }
138        }
139    
140        Ok((&input[byte_count.into()..], value))
141    }
142
143    #[inline]
144    fn to_be_bits(&self, byte_count: u8) -> JResult<&'a [u8], u128> {
145        self.to_bits(ByteOrder::Be, byte_count)
146    }
147
148    #[inline]
149    fn to_le_bits(&self, byte_count: u8) -> JResult<&'a [u8], u128> {
150        self.to_bits(ByteOrder::Le, byte_count)
151    }
152}
153
154
155#[cfg(test)]
156mod test {
157    use super::*;
158
159    #[test]
160    fn test_input_trait() {
161        let input = &b"\x00\x01\x00\x02"[..];
162        let (input, value) = input.to_be_bits(2).unwrap();
163        assert_eq!(value, 0x0001);
164        assert_eq!(input, b"\x00\x02");
165
166        let (input, value) = input.to_le_bits(2).unwrap();
167        assert_eq!(value, 0x0200);
168        assert_eq!(input.is_empty(), true);
169
170        let input = &b"\x00\x01\x00\x02"[..];
171        let (input, value) = input.input_take(2).unwrap();
172        assert_eq!(value, b"\x00\x01");
173        assert_eq!(input, b"\x00\x02");
174
175        let input = &b"\x00\x01\x00\x02"[..];
176        let (input, value) = input.find_subsequence(b"\x01\x00", false).unwrap();
177        assert_eq!(value, b"\x00");
178        assert_eq!(input, b"\x02");
179
180        let input = &b"\x00\x01\x00\x02"[..];
181        let (input, value) = input.find_subsequence(b"\x01\x00", true).unwrap();
182        assert_eq!(value, b"\x00\x01\x00");
183        assert_eq!(input, b"\x02");
184    }
185}
jppe/input.rs

jppe/
input.rs
