libutils 5.26.14

Common library types for faster development
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

//^
//^ HEAD
//^

//> HEAD -> SUPER
use super::Array;

//> HEAD -> CORE
use core::{
    mem::{
        MaybeUninit,
        forget
    },
    slice::{
        Iter,
        IterMut
    }
};


//^
//^ ITERATORS
//^

//> ITERATORS -> ITERABLE
pub struct Iterable<Type, const N: usize> {
    index: usize,
    length: usize,
    data: MaybeUninit<[Type; N]>
}

//> ITERATORS -> ITERATIONS
impl<Type, const N: usize> Iterator for Iterable<Type, N> {
    type Item = Type;
    fn next(&mut self) -> Option<Self::Item> {
        return if self.index >= self.length {None} else {
            let value = unsafe {(self.data.as_ptr() as *const Type).add(self.index).read()};
            self.index += 1;
            return Some(value);
        }
    }
}

//> ITERATORS -> FROM
impl<Type, const N: usize> FromIterator<Type> for Array<Type, N> {
    fn from_iter<T: IntoIterator<Item = Type>>(iter: T) -> Self {
        let mut array = Self::new();
        array.extend(iter);
        return array;
    }
}

//> ITERATORS -> INTO ITERATOR
impl<Type, const N: usize> IntoIterator for Array<Type, N> {
    type Item = Type;
    type IntoIter = Iterable<Type, N>;
    fn into_iter(self) -> Self::IntoIter {
        let iterator = Self::IntoIter {
            index: 0,
            length: self.length,
            data: unsafe {MaybeUninit::new(self.data.as_ptr().read())}
        };
        forget(self);
        return iterator;
    }
}

//> ITERATORS -> BORROWED
impl<'valid, Type, const N: usize> IntoIterator for &'valid Array<Type, N> {
    type Item = &'valid Type;
    type IntoIter = Iter<'valid, Type>;
    fn into_iter(self) -> Self::IntoIter {self.as_ref().iter()}
}

//> ITERATORS -> BORROWED MUTABLY
impl<'valid, Type, const N: usize> IntoIterator for &'valid mut Array<Type, N> {
    type Item = &'valid mut Type;
    type IntoIter = IterMut<'valid, Type>;
    fn into_iter(self) -> Self::IntoIter {self.as_mut().iter_mut()}
}

//> ITERATORS -> METHODS
impl<Type, const N: usize> Array<Type, N> {
    #[inline]
    pub fn iter<'valid>(&'valid self) -> Iter<'valid, Type> {return self.as_ref().into_iter()}
    #[inline]
    pub fn iter_mut<'valid>(&'valid mut self) -> IterMut<'valid, Type> {return self.as_mut().into_iter()}
}