vec_split 0.1.4

Splits arrays of vectors into arrays of items.
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

use std::{
    marker::PhantomData,
    ops::{Index, IndexMut},
};

use crate::*;

/// The immutable fast accessor. Contains a reference to the array, and the
/// dimension to get from the vectors. Unlike the Fast accessor, this can be
/// used for **ALL** types of vectors and arrays.
pub struct SafeAccessor<
    'a,
    T: ?Sized,
    const D: usize,
    V: Vector<T, D>,
    I,
    VA: VectorArray<T, D, V, I>,
> {
    phantom_t: PhantomData<T>,
    phantom_v: PhantomData<V>,
    phantom_i: PhantomData<I>,
    array_ref: &'a VA,
    dim: usize,
}

impl<'a, T: ?Sized, const D: usize, V: Vector<T, D>, I, VA: VectorArray<T, D, V, I>>
    SafeAccessor<'a, T, D, V, I, VA>
{
    pub(crate) fn new(array_ref: &'a VA, dim: usize) -> Self {
        Self {
            phantom_t: PhantomData,
            phantom_v: PhantomData,
            phantom_i: PhantomData,
            array_ref,
            dim,
        }
    }
}

impl<'a, T: ?Sized, const D: usize, V: Vector<T, D>, I, VA: VectorArray<T, D, V, I>> Index<I>
    for SafeAccessor<'a, T, D, V, I, VA>
{
    type Output = T;

    fn index(&self, index: I) -> &Self::Output {
        self.get(index).expect("index is too large for array.")
    }
}

impl<'a, T: ?Sized, const D: usize, V: Vector<T, D>, I, VA: VectorArray<T, D, V, I>> Accessor<T, I>
    for SafeAccessor<'a, T, D, V, I, VA>
{
    fn get<'b>(&'b self, index: I) -> Option<&'b T> {
        self.array_ref.get(index).map(|x| x.get(self.dim).unwrap())
    }
}

/// The mutable fast accessor. Contains a mutable reference to the array, and
/// the dimension to get from the vectors. Unlike the Fast accessor, this can
/// be used for **ALL** types of vectors and arrays.
pub struct SafeAccessorMut<
    'a,
    T: ?Sized,
    const D: usize,
    V: Vector<T, D>,
    I,
    VA: VectorArray<T, D, V, I>,
> {
    phantom_t: PhantomData<T>,
    phantom_v: PhantomData<V>,
    phantom_i: PhantomData<I>,
    array_ref: &'a mut VA,
    dim: usize,
}

impl<'a, T: ?Sized, const D: usize, V: Vector<T, D>, I, VA: VectorArray<T, D, V, I>>
    SafeAccessorMut<'a, T, D, V, I, VA>
{
    pub(crate) fn new(array_ref: &'a mut VA, dim: usize) -> Self {
        Self {
            phantom_t: PhantomData,
            phantom_v: PhantomData,
            phantom_i: PhantomData,
            array_ref,
            dim,
        }
    }
}

impl<'a, T: ?Sized, const D: usize, V: Vector<T, D>, I, VA: VectorArray<T, D, V, I>> Accessor<T, I>
    for SafeAccessorMut<'a, T, D, V, I, VA>
{
    fn get<'b>(&'b self, index: I) -> Option<&'b T> {
        self.array_ref.get(index).map(|x| x.get(self.dim).unwrap())
    }
}
impl<'a, T: ?Sized, const D: usize, V: Vector<T, D>, I, VA: VectorArray<T, D, V, I>>
    AccessorMut<T, I> for SafeAccessorMut<'a, T, D, V, I, VA>
{
    fn get_mut<'b>(&'b mut self, index: I) -> Option<&'b mut T> {
        self.array_ref
            .get_mut(index)
            .map(|x| x.get_mut(self.dim).unwrap())
    }
}

impl<'a, T: ?Sized, const D: usize, V: Vector<T, D>, I, VA: VectorArray<T, D, V, I>> Index<I>
    for SafeAccessorMut<'a, T, D, V, I, VA>
{
    type Output = T;

    fn index(&self, index: I) -> &Self::Output {
        self.get(index).expect("index is too large for array.")
    }
}

impl<'a, T: ?Sized, const D: usize, V: Vector<T, D>, I, VA: VectorArray<T, D, V, I>> IndexMut<I>
    for SafeAccessorMut<'a, T, D, V, I, VA>
{
    fn index_mut(&mut self, index: I) -> &mut Self::Output {
        self.get_mut(index).expect("index is too large for array.")
    }
}