array__ops 1.0.3

A selection of useful array operations
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

use core::{marker::Destruct, mem::MaybeUninit};

use super::{ArrayExtend, Truncate};

#[const_trait]
pub trait ArrayResize<T, const N: usize>: Truncate<T, N> + ArrayExtend<T, N>
{
    fn resize<const M: usize, F>(self, fill: F) -> [T; M]
    where
        F: FnMut(usize) -> T + ~const Destruct,
        T: ~const Destruct;
    fn rresize<const M: usize, F>(self, fill: F) -> [T; M]
    where
        F: FnMut(usize) -> T + ~const Destruct,
        T: ~const Destruct;
}

impl<T, const N: usize> ArrayResize<T, N> for [T; N]
{
    fn resize<const M: usize, F>(mut self, mut fill: F) -> [T; M]
    where
        F: FnMut(usize) -> T + Destruct,
        T: Destruct
    {
        let overlap = N.min(M);

        if M < N
        {
            // Drop truncated elements
            unsafe {
                core::ptr::drop_in_place(&mut self[M..N]);
            }
        }

        let src = self.as_ptr();

        if M <= N
        {
            // If not larger than original, dont make a new uninit, instead read directly from original
            let array = unsafe {
                core::ptr::read(src.cast())
            };
            core::mem::forget(self);
            return array;
        }
    
        // Make new uninit array
        let mut array = MaybeUninit::uninit_array();
        let mut dst = (&mut array as *mut MaybeUninit<T>).cast::<T>();
    
        // Copy over
        unsafe {core::ptr::copy_nonoverlapping(src, dst, overlap)};
        core::mem::forget(self);
    
        // Extend with fill
        let mut i = N;
        dst = unsafe {dst.add(N)};
        while i < M
        {
            unsafe {core::ptr::write(dst, fill(i))};
            i += 1;
            dst = unsafe {dst.add(1)};
        }
        unsafe {
            MaybeUninit::array_assume_init(array)
        }
    }
    fn rresize<const M: usize, F>(mut self, mut fill: F) -> [T; M]
    where
        F: FnMut(usize) -> T + Destruct,
        T: Destruct
    {
        let trunc = N.saturating_sub(M);
        let offset = M.saturating_sub(N);
        let overlap = N.min(M);

        if M < N
        {
            // Drop truncated elements
            unsafe {
                core::ptr::drop_in_place(&mut self[0..trunc]);
            }
        }

        let src = unsafe {
            self.as_ptr().add(trunc)
        };

        if M <= N
        {
            // If not larger than original, dont make a new uninit, instead read directly from original
            let array = unsafe {
                core::ptr::read(src.cast())
            };
            core::mem::forget(self);
            return array;
        }
        
        // Make new uninit array
        let mut array = MaybeUninit::uninit_array();
        let mut dst = unsafe {
            (&mut array as *mut MaybeUninit<T>).cast::<T>().add(offset)
        };
    
        // Copy over
        unsafe {core::ptr::copy_nonoverlapping(src, dst, overlap)};
        core::mem::forget(self);
    
        // Extend with fill
        let mut i = offset;
        while i > 0
        {
            i -= 1;
            dst = unsafe {dst.sub(1)};
            unsafe {core::ptr::write(dst, fill(i))};
        }
    
        unsafe {
            MaybeUninit::array_assume_init(array)
        }
    }
}