mdarray 0.8.0

Multidimensional array for Rust
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

use core::fmt::{Debug, Formatter, Result};
use core::mem::ManuallyDrop;
use core::ptr;

use crate::buffer::Buffer;
use crate::expr::expression::Expression;
use crate::expr::iter::Iter;
use crate::slice::Slice;

/// Expression that moves elements out of an array.
pub struct IntoExpr<T, B: Buffer<Item = ManuallyDrop<T>>> {
    buffer: B,
    index: usize,
}

impl<T, B: Buffer<Item = ManuallyDrop<T>>> IntoExpr<T, B> {
    /// Creates an expression from an array buffer.
    #[inline]
    pub fn new(buffer: B) -> Self {
        Self { buffer, index: 0 }
    }
}

impl<T, B: Buffer<Item = ManuallyDrop<T>>> AsMut<Slice<T, B::Shape>> for IntoExpr<T, B> {
    #[inline]
    fn as_mut(&mut self) -> &mut Slice<T, B::Shape> {
        debug_assert!(self.index == 0, "expression in use");

        unsafe {
            &mut *(self.buffer.as_mut_slice() as *mut Slice<ManuallyDrop<T>, B::Shape>
                as *mut Slice<T, B::Shape>)
        }
    }
}

impl<T, B: Buffer<Item = ManuallyDrop<T>>> AsRef<Slice<T, B::Shape>> for IntoExpr<T, B> {
    #[inline]
    fn as_ref(&self) -> &Slice<T, B::Shape> {
        debug_assert!(self.index == 0, "expression in use");

        unsafe {
            &*(self.buffer.as_slice() as *const Slice<ManuallyDrop<T>, B::Shape>
                as *const Slice<T, B::Shape>)
        }
    }
}

impl<T, B: Buffer<Item = ManuallyDrop<T>> + Clone> Clone for IntoExpr<T, B> {
    #[inline]
    fn clone(&self) -> Self {
        assert!(self.index == 0, "expression in use");

        Self { buffer: self.buffer.clone(), index: 0 }
    }

    #[inline]
    fn clone_from(&mut self, source: &Self) {
        assert!(self.index == 0 && source.index == 0, "expression in use");

        self.buffer.clone_from(&source.buffer);
    }
}

impl<T: Debug, B: Buffer<Item = ManuallyDrop<T>>> Debug for IntoExpr<T, B> {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        f.debug_tuple("IntoExpr").field(&self.as_ref()).finish()
    }
}

impl<T, B: Buffer<Item = ManuallyDrop<T>> + Default> Default for IntoExpr<T, B> {
    #[inline]
    fn default() -> Self {
        Self { buffer: Default::default(), index: 0 }
    }
}

impl<T, B: Buffer<Item = ManuallyDrop<T>>> Drop for IntoExpr<T, B> {
    #[inline]
    fn drop(&mut self) {
        unsafe {
            let ptr = self.buffer.as_mut_slice().as_mut_ptr().add(self.index) as *mut T;
            let len = self.buffer.as_slice().len() - self.index;

            ptr::slice_from_raw_parts_mut(ptr, len).drop_in_place();
        }
    }
}

impl<T, B: Buffer<Item = ManuallyDrop<T>>> Expression for IntoExpr<T, B> {
    type Shape = B::Shape;

    const IS_REPEATABLE: bool = false;

    #[inline]
    fn shape(&self) -> &B::Shape {
        self.buffer.as_slice().shape()
    }

    #[inline]
    unsafe fn get_unchecked(&mut self, _: usize) -> T {
        debug_assert!(self.index < self.buffer.as_slice().len(), "index out of bounds");

        self.index += 1; // Keep track of that the element is moved out.

        unsafe {
            ManuallyDrop::take(&mut *self.buffer.as_mut_slice().as_mut_ptr().add(self.index - 1))
        }
    }

    #[inline]
    fn inner_rank(&self) -> usize {
        usize::MAX
    }

    #[inline]
    unsafe fn reset_dim(&mut self, _: usize, _: usize) {}

    #[inline]
    unsafe fn step_dim(&mut self, _: usize) {}
}

impl<T, B: Buffer<Item = ManuallyDrop<T>>> IntoIterator for IntoExpr<T, B> {
    type Item = T;
    type IntoIter = Iter<Self>;

    #[inline]
    fn into_iter(self) -> Iter<Self> {
        Iter::new(self)
    }
}