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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
use crate::dimension::{self, stride_offset};
use crate::extension::nonnull::nonnull_debug_checked_from_ptr;
use crate::imp_prelude::*;
use crate::{is_aligned, StrideShape};
impl<A, D> RawArrayView<A, D>
where
D: Dimension,
{
/// Create a new `RawArrayView`.
///
/// Unsafe because caller is responsible for ensuring that the array will
/// meet all of the invariants of the `ArrayBase` type.
#[inline(always)]
pub(crate) unsafe fn new_(ptr: *const A, dim: D, strides: D) -> Self {
RawArrayView {
data: RawViewRepr::new(),
ptr: nonnull_debug_checked_from_ptr(ptr as *mut _),
dim,
strides,
}
}
/// Create an `RawArrayView<A, D>` from shape information and a raw pointer
/// to the elements.
///
/// Unsafe because caller is responsible for ensuring all of the following:
///
/// * `ptr` must be non-null and aligned, and it must be safe to
/// [`.offset()`] `ptr` by zero.
///
/// * It must be safe to [`.offset()`] the pointer repeatedly along all
/// axes and calculate the `count`s for the `.offset()` calls without
/// overflow, even if the array is empty or the elements are zero-sized.
///
/// In other words,
///
/// * All possible pointers generated by moving along all axes must be in
/// bounds or one byte past the end of a single allocation with element
/// type `A`. The only exceptions are if the array is empty or the element
/// type is zero-sized. In these cases, `ptr` may be dangling, but it must
/// still be safe to [`.offset()`] the pointer along the axes.
///
/// * The offset in units of bytes between the least address and greatest
/// address by moving along all axes must not exceed `isize::MAX`. This
/// constraint prevents the computed offset, in bytes, from overflowing
/// `isize` regardless of the starting point due to past offsets.
///
/// * The offset in units of `A` between the least address and greatest
/// address by moving along all axes must not exceed `isize::MAX`. This
/// constraint prevents overflow when calculating the `count` parameter to
/// [`.offset()`] regardless of the starting point due to past offsets.
///
/// * The product of non-zero axis lengths must not exceed `isize::MAX`.
///
/// [`.offset()`]: https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.offset
pub unsafe fn from_shape_ptr<Sh>(shape: Sh, ptr: *const A) -> Self
where
Sh: Into<StrideShape<D>>,
{
let shape = shape.into();
let dim = shape.dim;
let strides = shape.strides;
if cfg!(debug_assertions) {
assert!(!ptr.is_null(), "The pointer must be non-null.");
assert!(is_aligned(ptr), "The pointer must be aligned.");
dimension::max_abs_offset_check_overflow::<A, _>(&dim, &strides).unwrap();
}
RawArrayView::new_(ptr, dim, strides)
}
/// Converts to a read-only view of the array.
///
/// **Warning** from a safety standpoint, this is equivalent to
/// dereferencing a raw pointer for every element in the array. You must
/// ensure that all of the data is valid and choose the correct lifetime.
#[inline]
pub unsafe fn deref_into_view<'a>(self) -> ArrayView<'a, A, D> {
ArrayView::new_(self.ptr.as_ptr(), self.dim, self.strides)
}
/// Split the array view along `axis` and return one array pointer strictly
/// before the split and one array pointer after the split.
///
/// **Panics** if `axis` or `index` is out of bounds.
pub fn split_at(self, axis: Axis, index: Ix) -> (Self, Self) {
assert!(index <= self.len_of(axis));
let left_ptr = self.ptr.as_ptr();
let right_ptr = if index == self.len_of(axis) {
self.ptr.as_ptr()
} else {
let offset = stride_offset(index, self.strides.axis(axis));
// The `.offset()` is safe due to the guarantees of `RawData`.
unsafe { self.ptr.as_ptr().offset(offset) }
};
let mut dim_left = self.dim.clone();
dim_left.set_axis(axis, index);
let left = unsafe { Self::new_(left_ptr, dim_left, self.strides.clone()) };
let mut dim_right = self.dim;
let right_len = dim_right.axis(axis) - index;
dim_right.set_axis(axis, right_len);
let right = unsafe { Self::new_(right_ptr, dim_right, self.strides) };
(left, right)
}
}
impl<A, D> RawArrayViewMut<A, D>
where
D: Dimension,
{
/// Create a new `RawArrayViewMut`.
///
/// Unsafe because caller is responsible for ensuring that the array will
/// meet all of the invariants of the `ArrayBase` type.
#[inline(always)]
pub(crate) unsafe fn new_(ptr: *mut A, dim: D, strides: D) -> Self {
RawArrayViewMut {
data: RawViewRepr::new(),
ptr: nonnull_debug_checked_from_ptr(ptr),
dim,
strides,
}
}
/// Create an `RawArrayViewMut<A, D>` from shape information and a raw
/// pointer to the elements.
///
/// Unsafe because caller is responsible for ensuring all of the following:
///
/// * `ptr` must be non-null and aligned, and it must be safe to
/// [`.offset()`] `ptr` by zero.
///
/// * It must be safe to [`.offset()`] the pointer repeatedly along all
/// axes and calculate the `count`s for the `.offset()` calls without
/// overflow, even if the array is empty or the elements are zero-sized.
///
/// In other words,
///
/// * All possible pointers generated by moving along all axes must be in
/// bounds or one byte past the end of a single allocation with element
/// type `A`. The only exceptions are if the array is empty or the element
/// type is zero-sized. In these cases, `ptr` may be dangling, but it must
/// still be safe to [`.offset()`] the pointer along the axes.
///
/// * The offset in units of bytes between the least address and greatest
/// address by moving along all axes must not exceed `isize::MAX`. This
/// constraint prevents the computed offset, in bytes, from overflowing
/// `isize` regardless of the starting point due to past offsets.
///
/// * The offset in units of `A` between the least address and greatest
/// address by moving along all axes must not exceed `isize::MAX`. This
/// constraint prevents overflow when calculating the `count` parameter to
/// [`.offset()`] regardless of the starting point due to past offsets.
///
/// * The product of non-zero axis lengths must not exceed `isize::MAX`.
///
/// [`.offset()`]: https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.offset
pub unsafe fn from_shape_ptr<Sh>(shape: Sh, ptr: *mut A) -> Self
where
Sh: Into<StrideShape<D>>,
{
let shape = shape.into();
let dim = shape.dim;
let strides = shape.strides;
if cfg!(debug_assertions) {
assert!(!ptr.is_null(), "The pointer must be non-null.");
assert!(is_aligned(ptr), "The pointer must be aligned.");
dimension::max_abs_offset_check_overflow::<A, _>(&dim, &strides).unwrap();
}
RawArrayViewMut::new_(ptr, dim, strides)
}
/// Converts to a non-mutable `RawArrayView`.
#[inline]
pub(crate) fn into_raw_view(self) -> RawArrayView<A, D> {
unsafe { RawArrayView::new_(self.ptr.as_ptr(), self.dim, self.strides) }
}
/// Converts to a read-only view of the array.
///
/// **Warning** from a safety standpoint, this is equivalent to
/// dereferencing a raw pointer for every element in the array. You must
/// ensure that all of the data is valid and choose the correct lifetime.
#[inline]
pub unsafe fn deref_into_view<'a>(self) -> ArrayView<'a, A, D> {
ArrayView::new_(self.ptr.as_ptr(), self.dim, self.strides)
}
/// Converts to a mutable view of the array.
///
/// **Warning** from a safety standpoint, this is equivalent to
/// dereferencing a raw pointer for every element in the array. You must
/// ensure that all of the data is valid and choose the correct lifetime.
#[inline]
pub unsafe fn deref_into_view_mut<'a>(self) -> ArrayViewMut<'a, A, D> {
ArrayViewMut::new_(self.ptr.as_ptr(), self.dim, self.strides)
}
/// Split the array view along `axis` and return one array pointer strictly
/// before the split and one array pointer after the split.
///
/// **Panics** if `axis` or `index` is out of bounds.
pub fn split_at(self, axis: Axis, index: Ix) -> (Self, Self) {
let (left, right) = self.into_raw_view().split_at(axis, index);
unsafe {
(
Self::new_(left.ptr.as_ptr(), left.dim, left.strides),
Self::new_(right.ptr.as_ptr(), right.dim, right.strides),
)
}
}
}