offset-views 0.1.2

Create and index offset views of arrays, slices, strings, etc.
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

/// Functionality to add an offset to a value and convert it.
///
/// # Examples
///
/// ```rust
/// use offset_views::with_offset::WithOffset;
/// assert_eq!(3.with_offset(5), 8);
/// assert_eq!((3..8).with_offset(-3), 0..5);
/// ```
pub trait WithOffset<O> {
    type Output;
    /// Adds an offset to a value and tries to convert the result to a suitable output type.
    ///
    /// This method may panic if it is not possible to represent the result in the output type.
    fn with_offset(&self, offset: O) -> Self::Output;
}

impl WithOffset<isize> for isize {
    type Output = usize;
    fn with_offset(&self, offset: isize) -> usize {
        (self + offset)
            .try_into()
            .expect("cannot convert to `usize`")
    }
}

use std::ops::{Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive};

impl<I> WithOffset<isize> for Range<I>
where
    I: WithOffset<isize, Output = usize>,
{
    type Output = Range<usize>;
    fn with_offset(&self, offset: isize) -> Range<usize> {
        self.start.with_offset(offset)..self.end.with_offset(offset)
    }
}

impl<I> WithOffset<isize> for RangeInclusive<I>
where
    I: WithOffset<isize, Output = usize>,
{
    type Output = RangeInclusive<usize>;
    fn with_offset(&self, offset: isize) -> RangeInclusive<usize> {
        self.start().with_offset(offset)..=self.end().with_offset(offset)
    }
}

impl<I> WithOffset<isize> for RangeFrom<I>
where
    I: WithOffset<isize, Output = usize>,
{
    type Output = RangeFrom<usize>;
    fn with_offset(&self, offset: isize) -> RangeFrom<usize> {
        self.start.with_offset(offset)..
    }
}

impl<I> WithOffset<isize> for RangeTo<I>
where
    I: WithOffset<isize, Output = usize>,
{
    type Output = RangeTo<usize>;
    fn with_offset(&self, offset: isize) -> RangeTo<usize> {
        ..self.end.with_offset(offset)
    }
}

impl<I> WithOffset<isize> for RangeToInclusive<I>
where
    I: WithOffset<isize, Output = usize>,
{
    type Output = RangeToInclusive<usize>;
    fn with_offset(&self, offset: isize) -> RangeToInclusive<usize> {
        ..=self.end.with_offset(offset)
    }
}

impl WithOffset<isize> for RangeFull {
    type Output = RangeFull;
    fn with_offset(&self, _offset: isize) -> RangeFull {
        RangeFull
    }
}

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

    #[test]
    fn isize() {
        assert_eq!(0.with_offset(5), 5);
        assert_panics!(0.with_offset(-5), includes("cannot convert to `usize`"));
        assert_eq!(3.with_offset(3), 6);
        assert_eq!(3.with_offset(-3), 0);
        assert_panics!(3.with_offset(-5), includes("cannot convert to `usize`"));
    }

    #[test]
    fn range() {
        assert_eq!((0..10).with_offset(3), 3..13);
        assert_eq!((3..13).with_offset(-3), 0..10);
        assert_panics!(
            (3..13).with_offset(-5),
            includes("cannot convert to `usize`")
        );
    }

    #[test]
    fn range_inclusive() {
        assert_eq!((0..=10).with_offset(3), 3..=13);
        assert_eq!((3..=13).with_offset(-3), 0..=10);
        assert_panics!(
            (3..=13).with_offset(-5),
            includes("cannot convert to `usize`")
        );
    }

    #[test]
    fn range_from() {
        assert_eq!((0..).with_offset(3), 3..);
        assert_eq!((3..).with_offset(-3), 0..);
        assert_panics!((3..).with_offset(-5), includes("cannot convert to `usize`"));
    }

    #[test]
    fn range_to() {
        assert_eq!((..10).with_offset(3), ..13);
        assert_eq!((..13).with_offset(-3), ..10);
        assert_eq!((..13).with_offset(-5), (..8));
    }

    #[test]
    fn range_to_inclusive() {
        assert_eq!((..=10).with_offset(3), ..=13);
        assert_eq!((..=13).with_offset(-3), ..=10);
        assert_eq!((..=13).with_offset(-5), (..=8));
    }

    #[test]
    fn range_full() {
        assert_eq!(RangeFull.with_offset(5), RangeFull);
        assert_eq!(RangeFull.with_offset(-5), RangeFull);
    }
}