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), ) } } }