const_str/
bytes.rs

Help
1use crate::slice::subslice;
2
3use core::cmp::Ordering;
4
5pub const fn clone<const N: usize>(bytes: &[u8]) -> [u8; N] {
6    assert!(bytes.len() == N);
7    let mut buf = [0; N];
8    let mut i = 0;
9    while i < bytes.len() {
10        buf[i] = bytes[i];
11        i += 1;
12    }
13    buf
14}
15
16pub const fn equal(lhs: &[u8], rhs: &[u8]) -> bool {
17    if lhs.len() != rhs.len() {
18        return false;
19    }
20    let mut i = 0;
21    while i < lhs.len() {
22        if lhs[i] != rhs[i] {
23            return false;
24        }
25        i += 1;
26    }
27    true
28}
29
30pub const fn compare(lhs: &[u8], rhs: &[u8]) -> Ordering {
31    let lhs_len = lhs.len();
32    let rhs_len = rhs.len();
33    let min_len = if lhs_len < rhs_len { lhs_len } else { rhs_len };
34
35    let mut i = 0;
36    while i < min_len {
37        if lhs[i] < rhs[i] {
38            return Ordering::Less;
39        }
40        if lhs[i] > rhs[i] {
41            return Ordering::Greater;
42        }
43        i += 1;
44    }
45
46    if lhs_len < rhs_len {
47        Ordering::Less
48    } else if lhs_len > rhs_len {
49        Ordering::Greater
50    } else {
51        Ordering::Equal
52    }
53}
54
55pub const fn merge<const N: usize>(mut buf: [u8; N], bytes: &[u8]) -> [u8; N] {
56    assert!(N <= bytes.len());
57    let mut i = 0;
58    while i < bytes.len() {
59        buf[i] = bytes[i];
60        i += 1;
61    }
62    buf
63}
64
65pub const fn reversed<const N: usize>(mut arr: [u8; N]) -> [u8; N] {
66    let mut i = 0;
67    while i * 2 < N {
68        let a = arr[i];
69        let b = arr[N - 1 - i];
70        arr[i] = b;
71        arr[N - 1 - i] = a;
72        i += 1;
73    }
74    arr
75}
76
77pub const fn contains(haystack: &[u8], needle: &[u8]) -> bool {
78    let haystack_len = haystack.len();
79    let needle_len = needle.len();
80
81    let mut i = 0;
82    while i < haystack_len {
83        let mut j = 0;
84        while j < needle_len && i + j < haystack_len {
85            if haystack[i + j] != needle[j] {
86                break;
87            }
88            j += 1;
89        }
90        if j == needle_len {
91            return true;
92        }
93        i += 1;
94    }
95
96    false
97}
98
99pub const fn starts_with(haystack: &[u8], needle: &[u8]) -> bool {
100    let haystack_len = haystack.len();
101    let needle_len = needle.len();
102
103    if needle_len > haystack_len {
104        return false;
105    }
106
107    let mut i = 0;
108    while i < needle_len {
109        if haystack[i] != needle[i] {
110            break;
111        }
112        i += 1
113    }
114
115    i == needle_len
116}
117
118pub const fn ends_with(haystack: &[u8], needle: &[u8]) -> bool {
119    let haystack_len = haystack.len();
120    let needle_len = needle.len();
121
122    if needle_len > haystack_len {
123        return false;
124    }
125
126    let mut i = 0;
127    while i < needle_len {
128        if haystack[haystack_len - needle_len + i] != needle[i] {
129            break;
130        }
131        i += 1
132    }
133
134    i == needle_len
135}
136
137pub const fn strip_prefix<'s>(s: &'s [u8], prefix: &[u8]) -> Option<&'s [u8]> {
138    if starts_with(s, prefix) {
139        Some(subslice(s, prefix.len()..s.len()))
140    } else {
141        None
142    }
143}
144
145pub const fn strip_suffix<'s>(s: &'s [u8], suffix: &[u8]) -> Option<&'s [u8]> {
146    if ends_with(s, suffix) {
147        Some(subslice(s, 0..s.len() - suffix.len()))
148    } else {
149        None
150    }
151}
152
153#[cfg(test)]
154mod tests {
155    use super::*;
156
157    #[test]
158    fn test_reversed() {
159        let arr = [0, 1];
160        assert_eq!(reversed(arr), [1, 0]);
161
162        let arr = [0, 1, 2];
163        assert_eq!(reversed(arr), [2, 1, 0]);
164    }
165
166    #[test]
167    fn test_contains() {
168        macro_rules! test_contains {
169            (true, $haystack: expr, $needle: expr) => {
170                assert!(contains($haystack.as_ref(), $needle.as_ref()));
171            };
172            (false, $haystack: expr, $needle: expr) => {
173                assert!(!contains($haystack.as_ref(), $needle.as_ref()));
174            };
175        }
176
177        let buf = b"abcdefgh";
178        test_contains!(true, buf, b"");
179        test_contains!(true, buf, b"a");
180        test_contains!(true, buf, b"ef");
181        test_contains!(false, buf, b"xyz");
182
183        test_contains!(true, "asd", "");
184        test_contains!(true, "asd", "a");
185        test_contains!(true, "asdf", "sd");
186        test_contains!(false, "", "a");
187        test_contains!(false, "asd", "abcd");
188
189        test_contains!(true, "唐可可", "可");
190        test_contains!(true, "Liyuu", "i");
191        test_contains!(false, "Liyuu", "我");
192    }
193
194    #[test]
195    fn test_starts_with() {
196        assert!(starts_with(b"", b""));
197        assert!(starts_with(b"a", b""));
198        assert!(starts_with(b"a", b"a"));
199        assert!(!starts_with(b"", b"a"));
200        assert!(!starts_with(b"ba", b"a"));
201    }
202
203    #[test]
204    fn test_ends_with() {
205        assert!(ends_with(b"", b""));
206        assert!(ends_with(b"a", b""));
207        assert!(ends_with(b"a", b"a"));
208        assert!(!ends_with(b"", b"a"));
209        assert!(!ends_with(b"ab", b"a"));
210    }
211}
const_str/bytes.rs

const_str/
bytes.rs
