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

use std::ops::{Deref, Index};

/// A slice that wraps around its size.
///
/// It derefs to the underlying slice, so it implements all of the same
/// functions as a slice, with the exception of indexing.
///
/// # Example
/// ```
/// use wrapping::WrappingSlice;
///
/// let array: [&str; 1] = ["hello"];
/// let wrapping = WrappingSlice::from(&array[..]);
///
/// assert_eq!(wrapping[0], "hello");
/// assert_eq!(wrapping[1], "hello");
/// ```
pub struct WrappingSlice<'a, T>(&'a [T]);

impl<'a, T, I: Into<&'a [T]>> From<I> for WrappingSlice<'a, T> {
    fn from(slice: I) -> Self {
        WrappingSlice(slice.into())
    }
}

impl<'a, T> Deref for WrappingSlice<'a, T> {
    type Target = [T];

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<'a, T> Index<usize> for WrappingSlice<'a, T> {
    type Output = T;

    fn index(&self, index: usize) -> &Self::Output {
        &self.0[index % self.0.len()]
    }
}