select_indices 3.0.0-alpha

Iterators for taking multiple shared/exclusive references from a slice
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

pub(crate) struct SelectIndicesBase<'a, T, I>
{
    pub(crate) data: T,
    pub(crate) indices: &'a [I],
    pub(crate) start: usize,
    pub(crate) end: usize,
}

use num_traits::{ PrimInt, ToPrimitive };

use std::collections::HashSet;

impl<T, I: Copy + Clone + PrimInt + ToPrimitive> SelectIndicesBase<'_, &[T], I>
{
    pub(crate) fn safety_check(slice: &[T], indices: &[I])
    {
        let len = slice.len();
        let indices_len = indices.len();
        
        indices.iter().for_each(|&i| {
            let i = i.to_usize()
                .expect("select_indices was given indices that cannot be converted to usize!");
            assert!(i < len, "select_indices was given an out-of-bounds index!");
        });
    }
}

impl<T, I: Copy + Clone + PrimInt + ToPrimitive> SelectIndicesBase<'_, &mut [T], I>
{
    pub(crate) fn safety_check(slice: &mut [T], indices: &[I])
    {
        let len = slice.len();
        let indices_len = indices.len();

        // If indices is longer than the slice, either there are
        // duplicates, or some indices are out of bounds.
        assert!(indices_len <= len,
            "select_indices_mut was passed more indices than are possible without breaking mutability rules!"); 

        let mut indexset = HashSet::with_capacity(indices_len);
        // TODO: Safety checks without heap allocation
        
        indices.iter().for_each(|&i| {
            let i = i.to_usize()
                .expect("select_indices_mut was given indices that cannot be converted to usize!");
            assert!(i < len, "select_indices_mut was passed an out-of-bounds index!");
            assert!(indexset.insert(i), "select_indices_mut was passed a duplicate index!");
        });
    }
}

impl<'a, T: 'a, I: Copy + Clone + PrimInt + ToPrimitive> Iterator for SelectIndicesBase<'a, &'a [T], I>
{
    type Item = &'a T;

    fn next(&mut self) -> Option<Self::Item> {
        if self.start < self.end
        {
            let ind = unsafe { *self.indices.get_unchecked(self.start) };
            self.start += 1;
            return Some(unsafe { 
                self.data.get_unchecked(
                    ind.to_usize()
                    .expect("select_indices was given indices that cannot be converted to usize!")
                ) 
            });
        }
        else {
            return None;
        }
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        let len = self.indices.len();
        return (len, Some(len));
    }
}
impl<'a, T: 'a, I: Copy + Clone + PrimInt + ToPrimitive> DoubleEndedIterator for SelectIndicesBase<'a, &'a [T], I>
{
    fn next_back(&mut self) -> Option<Self::Item> {
        if self.start < self.end
        {
            self.end -= 1;
            let ind = unsafe { * self.indices.get_unchecked(self.end) };
            return Some(unsafe {
                self.data.get_unchecked(
                    ind.to_usize()
                    .expect("select_indices was given indices that cannot be converted to usize!")
                )
            });
        }
        else {
            return None;
        }
    }
}
impl<'a, T: 'a, I: Copy + Clone + PrimInt + ToPrimitive> ExactSizeIterator for SelectIndicesBase<'a, &'a [T], I> {}

impl<'a, T: 'a, I: Copy + Clone + PrimInt + ToPrimitive> Iterator for SelectIndicesBase<'a, &'a mut [T], I>
{
    type Item = &'a mut T;

    fn next(&mut self) -> Option<Self::Item> {
        if self.start < self.end
        {
            let ind = unsafe { *self.indices.get_unchecked(self.start) };
            self.start += 1;
            return Some(unsafe {
                &mut *self.data.as_mut_ptr().add(
                    ind.to_usize()
                    .expect("select_indices was given indices that cannot be converted to usize!")
                )
            });
        }
        else {
            return None;
        }
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        let len = self.indices.len();
        return (len, Some(len));
    }
}
impl<'a, T: 'a, I: Copy + Clone + PrimInt + ToPrimitive> DoubleEndedIterator for SelectIndicesBase<'a, &'a mut [T], I>
{
    fn next_back(&mut self) -> Option<Self::Item> {
        if self.start < self.end
        {
            self.end -= 1;
            let ind = unsafe { *self.indices.get_unchecked(self.end) };
            return Some(unsafe {
                &mut *self.data.as_mut_ptr().add(
                    ind.to_usize()
                    .expect("select_indices was given indices that cannot be converted to usize!")
                )
            });
        }
        else {
            return None;
        }
    }
}
impl<'a, T: 'a, I: Copy + Clone + PrimInt + ToPrimitive> ExactSizeIterator for SelectIndicesBase<'a, &'a mut [T], I> {}