extra 0.1.0

Extra stuff the standard library lacks of.
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

extern crate collections;

/// Types which can be converted to an `Option<T>`.
pub trait AsOption<T> {
    /// Convert this value into an `Option`.
    fn as_option(&self) -> Option<T>;
}

impl AsOption<usize> for usize {
    fn as_option(&self) -> Option<usize> {
        Some(*self)
    }
}

impl AsOption<usize> for Option<usize> {
    fn as_option(&self) -> Option<usize> {
        *self
    }
}

use self::collections::range::RangeArgument;
use std::ops::Range;
use std::cmp;

/// Bounded slice abstraction.
///
/// # Code Migration
///
/// `foo[a..b]` => `foo.get_slice(a..b)`
///
/// `foo[a..]` => `foo.get_slice(a..)`
///
/// `foo[..b]` => `foo.get_slice(..b)`
///
pub trait GetSlice {
    /// Panic safely get a slice of a value. When out of bound, the bound will be saturated.
    fn get_slice<T: AsOption<usize>, U: RangeArgument<T>>(&self, a: U) -> &Self;
    /// Panic safely get a mutable slice of a value. When out of bound, the bound will be saturated.
    fn get_slice_mut<T: AsOption<usize>, U: RangeArgument<T>>(&mut self, a: U) -> &mut Self;
}

fn bound<T: AsOption<usize>, U: RangeArgument<T>>(len: usize, a: U) -> Range<usize> {
    let start = cmp::min(a.start().and_then(|x| x.as_option()).unwrap_or(0), len);
    let end = cmp::min(a.end().and_then(|x| x.as_option()).unwrap_or(len), len);

    if start <= end {
        start..end
    } else {
        0..0
    }
}

impl GetSlice for str {
    fn get_slice<T: AsOption<usize>, U: RangeArgument<T>>(&self, a: U) -> &Self {
        &self[bound(self.len(), a)]
    }

    fn get_slice_mut<T: AsOption<usize>, U: RangeArgument<T>>(&mut self, a: U) -> &mut Self {
        let len = self.len();
        &mut self[bound(len, a)]
    }
}

impl<T> GetSlice for [T] {
    fn get_slice<U: AsOption<usize>, V: RangeArgument<U>>(&self, a: V) -> &Self {
        &self[bound(self.len(), a)]
    }

    fn get_slice_mut<U: AsOption<usize>, V: RangeArgument<U>>(&mut self, a: V) -> &mut Self {
        let len = self.len();
        &mut self[bound(len, a)]
    }
}

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

    #[test]
    fn test_get_slice() {
        let arr = [1, 2, 3];
        assert_eq!(arr.get_slice(1..42), &[2, 3]);
        assert_eq!(arr.get_slice(20..42), &[]);
        assert_eq!(arr.get_slice(0..), &arr);
        assert_eq!(arr.get_slice::<usize, _>(..), &arr);
        assert_eq!(arr.get_slice(..42), &arr);
        assert_eq!(arr.get_slice(Some(1)..None), &[2, 3]);
        assert_eq!(arr.get_slice(Some(1)..Some(2)), &[2]);
        let mut vec = Vec::new();
        assert!(vec.get_slice(Some(1)..Some(2)).is_empty());
        vec.push(3);
        assert_eq!(vec.get_slice(0..2), &[3]);
        assert!(vec.get_slice(1..2).is_empty());
    }
}