resize_slice2 0.2.0

Resize a slice given a larger slice in safe Rust
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

use std::ops::Range;

/// Used to check if a slice is a slice of another slice.
///
/// # Examples
/// ```
/// # use resize_slice2::CouldBeSliceOf;
/// let source = &[1, 2, 3, 4, 5];
/// let slice = &source[1..3];
///
/// assert!(slice.is_slice_of(source));
///
/// let b = &[6, 7, 8];
/// assert!(!source.is_slice_of(b));
/// ```
pub trait CouldBeSliceOf<T> {
    /// Returns `true` if `self` could be a slice of `source`.
    fn is_slice_of(&self, source: &[T]) -> bool;
}

impl<T> CouldBeSliceOf<T> for &[T] {
    #[inline]
    fn is_slice_of(&self, source: &[T]) -> bool {
        let Range {
            start: outer_start,
            end: outer_end,
        } = source.as_ptr_range();
        let Range {
            start: inner_start,
            end: inner_end,
        } = self.as_ptr_range();

        outer_start as usize <= inner_start as usize && inner_end as usize <= outer_end as usize
    }
}

impl<T, const N: usize> CouldBeSliceOf<T> for &[T; N] {
    #[inline]
    fn is_slice_of(&self, source: &[T]) -> bool {
        let Range {
            start: outer_start,
            end: outer_end,
        } = source.as_ptr_range();
        let Range {
            start: inner_start,
            end: inner_end,
        } = self.as_ptr_range();

        outer_start as usize <= inner_start as usize && inner_end as usize <= outer_end as usize
    }
}

#[cfg(test)]
mod test {
    use super::*;

    static SOURCE: [i32; 10] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    #[test]
    fn simple() {
        let a = &SOURCE;
        let b = &a[1..3];

        assert!(b.is_slice_of(a));
        assert!(!a.is_slice_of(b));
    }

    #[test]
    fn simple_not() {
        let a = &SOURCE[..5];
        let b = &SOURCE[5..];

        assert!(!b.is_slice_of(a));
        assert!(!a.is_slice_of(b));
    }

    #[test]
    fn simple_not2() {
        let a = &SOURCE[..0];
        let b = &SOURCE[..1];

        assert!(a.is_slice_of(b));
        assert!(!b.is_slice_of(a));
    }

    #[test]
    fn same_to() {
        let a = &SOURCE;
        let b = &a[..5];

        assert!(b.is_slice_of(a));
        assert!(!a.is_slice_of(b));
    }

    #[test]
    fn same_from() {
        let a = &SOURCE;
        let b = &a[5..];

        assert!(b.is_slice_of(a));
        assert!(!a.is_slice_of(b));
    }

    #[test]
    fn same() {
        let a = SOURCE.as_ref();
        let b = SOURCE.as_ref();

        assert!(b.is_slice_of(a));
        assert!(a.is_slice_of(b));
    }

    #[test]
    fn same_empty() {
        let a = &SOURCE[0..0];
        let b = &SOURCE[0..0];

        assert!(b.is_slice_of(a));
        assert!(a.is_slice_of(b));
    }
}