aob_common 1.0.2

String searching with wildcards
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

use std::{
    marker::PhantomData,
    ops::RangeFrom,
    ptr::NonNull,
};

#[derive(Clone, Copy)]
pub(crate) struct ThinSlice<'a, T> {
    pub(crate) start: NonNull<T>,
    pub(crate) end: NonNull<T>,
    _phantom: PhantomData<&'a T>,
}

impl<'a, T> ThinSlice<'a, T> {
    /// SAFETY: `range` must be a subset of the range [`start`, `end`)
    #[must_use]
    pub(crate) unsafe fn get_unchecked(&self, range: RangeFrom<usize>) -> Self {
        Self {
            start: self.start.add(range.start),
            end: self.end,
            _phantom: PhantomData,
        }
    }

    #[must_use]
    pub(crate) fn is_empty(&self) -> bool {
        self.start == self.end
    }

    /// SAFETY: `mid` must be a valid offset in the range [`start`, `end`)
    #[must_use]
    pub(crate) unsafe fn split_at_unchecked<L, R>(
        &self,
        mid: usize,
    ) -> (ThinSlice<'a, L>, ThinSlice<'a, R>) {
        let mid = self.start.cast::<u8>().add(mid);
        let left = ThinSlice {
            start: self.start.cast(),
            end: mid.cast(),
            _phantom: PhantomData,
        };
        let right = ThinSlice {
            start: mid.cast(),
            end: self.end.cast(),
            _phantom: PhantomData,
        };
        (left, right)
    }
}

impl<'a, T> From<&'a [T]> for ThinSlice<'a, T> {
    fn from(value: &'a [T]) -> Self {
        let range = value.as_ptr_range();
        // SAFETY: pointers from a slice are always valid
        let (start, end) = unsafe {
            let start = NonNull::new_unchecked(range.start.cast_mut());
            let end = NonNull::new_unchecked(range.end.cast_mut());
            (start, end)
        };
        Self {
            start,
            end,
            _phantom: PhantomData,
        }
    }
}