safe stride constructor returns a Result

Author: vbarrielle

src/dimension.rs

@@ -2,6 +2,7 @@ use std::slice;
 
 use super::{Si, Ix, Ixs};
 use super::zipsl;
+use stride_error::StrideError;
 
 /// Calculate offset from `Ix` stride converting sign properly
 #[inline]
@@ -68,7 +69,7 @@ pub fn dim_stride_overlap<D: Dimension>(dim: &D, strides: &D) -> bool
 pub fn can_index_slice<A, D: Dimension>(data: &[A],
                                         dim: &D,
                                         strides: &D
-                                       ) -> bool
+                                       ) -> Result<(), StrideError>
 {
     if strides.slice().iter().cloned().all(stride_is_positive) {
         let mut last_index = dim.clone();
@@ -79,16 +80,16 @@ pub fn can_index_slice<A, D: Dimension>(data: &[A],
             // offset is guaranteed to be positive so no issue converting
             // to usize here
             if (offset as usize) >= data.len() {
-                return false;
+                return Err(StrideError::OutOfBoundsStride);
             }
             if dim_stride_overlap(dim, strides) {
-                return false;
+                return Err(StrideError::OutOfBoundsStride);
             }
         }
-        true
+        Ok(())
     }
     else {
-        false
+        Err(StrideError::NegativeStride)
     }
 }
 

src/lib.rs

@@ -84,6 +84,7 @@ pub use dimension::{
 pub use dimension::NdIndex;
 pub use indexes::Indexes;
 pub use shape_error::ShapeError;
+pub use stride_error::StrideError;
 pub use si::{Si, S};
 
 use dimension::stride_offset;
@@ -111,6 +112,7 @@ mod iterators;
 mod numeric_util;
 mod si;
 mod shape_error;
+mod stride_error;
 
 // NOTE: In theory, the whole library should compile
 // and pass tests even if you change Ix and Ixs.
@@ -665,13 +667,15 @@ impl<S, A, D> ArrayBase<S, D>
     pub fn from_vec_dim_stride(dim: D,
                                strides: D,
                                v: Vec<A>
-                              ) -> ArrayBase<S, D>
+                              ) -> Result<ArrayBase<S, D>, StrideError>
     {
-        assert!(dimension::can_index_slice(&v, &dim, &strides),
-                "dim and strides index out of the vector's memory");
-        unsafe {
-            Self::from_vec_dim_stride_uchk(dim, strides, v)
-        }
+        dimension::can_index_slice(&v,
+                                   &dim,
+                                   &strides).map(|_| {
+            unsafe {
+                Self::from_vec_dim_stride_uchk(dim, strides, v)
+            }
+        })
     }
 }
 

src/stride_error.rs

@@ -0,0 +1,32 @@
+use std::fmt;
+use std::error::Error;
+
+/// An error to describe invalid stride states
+#[derive(Clone, Debug, PartialEq)]
+pub enum StrideError {
+    /// stride leads to out of bounds indexing
+    OutOfBoundsStride,
+    /// stride leads to aliasing array elements
+    AliasingStride,
+    /// negative strides are unsafe in constructors
+    NegativeStride,
+}
+
+impl Error for StrideError {
+    fn description(&self) -> &str {
+        match *self {
+            StrideError::OutOfBoundsStride =>
+                "stride leads to out of bounds indexing",
+            StrideError::AliasingStride =>
+                "stride leads to aliasing array elements",
+            StrideError::NegativeStride =>
+                "negative strides are unsafe in constructors",
+        }
+    }
+}
+
+impl fmt::Display for StrideError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.description().fmt(f)
+    }
+}

tests/array.rs

@@ -394,6 +394,16 @@ fn owned_array1() {
     assert_eq!(d1, d2);
 }
 
+#[test]
+fn owned_array_with_stride() {
+    let v: Vec<_> = (0..12).collect();
+    let dim = (2, 3, 2);
+    let strides = (1, 4, 2);
+
+    let a = OwnedArray::from_vec_dim_stride(dim, strides, v).unwrap();
+    assert_eq!(a.strides(), &[1, 4, 2]);
+}
+
 #[test]
 fn views() {
     let a = Array::from_vec(vec![1, 2, 3, 4]).reshape((2, 2));

tests/dimension.rs

@@ -6,6 +6,7 @@ use ndarray::{
     arr2,
     can_index_slice,
     dim_stride_overlap,
+    StrideError,
 };
 
 #[test]
@@ -44,10 +45,11 @@ fn slice_indexing_uncommon_strides()
     let v: Vec<_> = (0..12).collect();
     let dim = (2, 3, 2);
     let strides = (1, 2, 6);
-    assert!(can_index_slice(&v, &dim, &strides));
+    assert!(can_index_slice(&v, &dim, &strides).is_ok());
 
     let strides = (2, 4, 12);
-    assert!(!can_index_slice(&v, &dim, &strides));
+    assert_eq!(can_index_slice(&v, &dim, &strides),
+               Err(StrideError::OutOfBoundsStride));
 }
 
 #[test]