Add is_*contiguous methods + Modify as_slice* returns Result

- To resolve #101, we check if the array is contiguous when getting a slice

Author: kngwyu

src/array.rs

@@ -145,6 +145,24 @@ impl<T, D> PyArray<T, D> {
         self.as_ptr() as _
     }
 
+    #[inline(always)]
+    fn check_flag(&self, flag: c_int) -> bool {
+        unsafe { (*self.as_array_ptr()).flags & flag == flag }
+    }
+
+    pub fn is_contiguous(&self) -> bool {
+        self.check_flag(npyffi::NPY_ARRAY_C_CONTIGUOUS)
+            | self.check_flag(npyffi::NPY_ARRAY_F_CONTIGUOUS)
+    }
+
+    pub fn is_forran_contiguous(&self) -> bool {
+        self.check_flag(npyffi::NPY_ARRAY_F_CONTIGUOUS)
+    }
+
+    pub fn is_c_contiguous(&self) -> bool {
+        self.check_flag(npyffi::NPY_ARRAY_C_CONTIGUOUS)
+    }
+
     /// Get `Py<PyArray>` from `&PyArray`, which is the owned wrapper of PyObject.
     ///
     /// You can use this method when you have to avoid lifetime annotation to your function args
@@ -404,15 +422,23 @@ impl<T: TypeNum, D: Dimension> PyArray<T, D> {
     /// assert_eq!(py_array.as_slice(), &[0, 1, 2, 3]);
     /// # }
     /// ```
-    pub fn as_slice(&self) -> &[T] {
-        self.type_check_assert();
-        unsafe { ::std::slice::from_raw_parts(self.data(), self.len()) }
+    pub fn as_slice(&self) -> Result<&[T], ErrorKind> {
+        self.type_check()?;
+        if !self.is_contiguous() {
+            Err(ErrorKind::NotContiguous)
+        } else {
+            Ok(unsafe { ::std::slice::from_raw_parts(self.data(), self.len()) })
+        }
     }
 
     /// Get the mmutable view of the internal data of `PyArray`, as slice.
-    pub fn as_slice_mut(&self) -> &mut [T] {
-        self.type_check_assert();
-        unsafe { ::std::slice::from_raw_parts_mut(self.data(), self.len()) }
+    pub fn as_slice_mut(&self) -> Result<&mut [T], ErrorKind> {
+        self.type_check()?;
+        if !self.is_contiguous() {
+            Err(ErrorKind::NotContiguous)
+        } else {
+            Ok(unsafe { ::std::slice::from_raw_parts_mut(self.data(), self.len()) })
+        }
     }
 
     /// Construct PyArray from `ndarray::ArrayBase`.
@@ -614,10 +640,7 @@ impl<T: TypeNum + Clone, D: Dimension> PyArray<T, D> {
     /// # }
     /// ```
     pub fn to_owned_array(&self) -> Array<T, D> {
-        unsafe {
-            let vec = self.as_slice().to_vec();
-            Array::from_shape_vec_unchecked(self.ndarray_shape(), vec)
-        }
+        self.as_array().to_owned()
     }
 }
 

src/error.rs

@@ -95,6 +95,8 @@ pub enum ErrorKind {
     FromVec { dim1: usize, dim2: usize },
     /// Error in numpy -> numpy data conversion
     PyToPy(Box<(ArrayShape, ArrayShape)>),
+    /// The array need to be contiguous to finish the opretion
+    NotContiguous,
 }
 
 impl ErrorKind {
@@ -146,6 +148,7 @@ impl fmt::Display for ErrorKind {
                 "Cast failed: from=ndarray({}), to=ndarray(dtype={})",
                 e.0, e.1,
             ),
+            ErrorKind::NotContiguous => write!(f, "This array is not contiguous!"),
         }
     }
 }
@@ -154,11 +157,7 @@ impl error::Error for ErrorKind {}
 
 impl From<ErrorKind> for PyErr {
     fn from(err: ErrorKind) -> PyErr {
-        match err {
-            ErrorKind::PyToRust { .. } | ErrorKind::FromVec { .. } | ErrorKind::PyToPy(_) => {
-                PyErr::new::<exc::TypeError, _>(format!("{}", err))
-            }
-        }
+        PyErr::new::<exc::TypeError, _>(format!("{}", err))
     }
 }
 
@@ -167,10 +166,6 @@ impl IntoPyErr for ErrorKind {
         Into::into(self)
     }
     fn into_pyerr_with<D: fmt::Display>(self, msg: impl FnOnce() -> D) -> PyErr {
-        match self {
-            ErrorKind::PyToRust { .. } | ErrorKind::FromVec { .. } | ErrorKind::PyToPy(_) => {
-                PyErr::new::<exc::TypeError, _>(format!("{}\n context: {}", self, msg()))
-            }
-        }
+        PyErr::new::<exc::TypeError, _>(format!("{}\n context: {}", self, msg()))
     }
 }

src/npyffi/flags.rs

@@ -0,0 +1,30 @@
+use std::os::raw::c_int;
+
+pub const NPY_ARRAY_C_CONTIGUOUS: c_int = 0x0001;
+pub const NPY_ARRAY_F_CONTIGUOUS: c_int = 0x0002;
+pub const NPY_ARRAY_OWNDATA: c_int = 0x0004;
+pub const NPY_ARRAY_FORCECAST: c_int = 0x0010;
+pub const NPY_ARRAY_ENSURECOPY: c_int = 0x0020;
+pub const NPY_ARRAY_ENSUREARRAY: c_int = 0x0040;
+pub const NPY_ARRAY_ELEMENTSTRIDES: c_int = 0x0080;
+pub const NPY_ARRAY_ALIGNED: c_int = 0x0100;
+pub const NPY_ARRAY_NOTSWAPPED: c_int = 0x0200;
+pub const NPY_ARRAY_WRITEABLE: c_int = 0x0400;
+pub const NPY_ARRAY_UPDATEIFCOPY: c_int = 0x1000;
+pub const NPY_ARRAY_WRITEBACKIFCOPY: c_int = 0x2000;
+pub const NPY_ARRAY_BEHAVED: c_int = NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEABLE;
+pub const NPY_ARRAY_BEHAVED_NS: c_int = NPY_ARRAY_BEHAVED | NPY_ARRAY_NOTSWAPPED;
+pub const NPY_ARRAY_CARRAY: c_int = NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_BEHAVED;
+pub const NPY_ARRAY_CARRAY_RO: c_int = NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_ALIGNED;
+pub const NPY_ARRAY_FARRAY: c_int = NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_BEHAVED;
+pub const NPY_ARRAY_FARRAY_RO: c_int = NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_ALIGNED;
+pub const NPY_ARRAY_DEFAULT: c_int = NPY_ARRAY_CARRAY;
+pub const NPY_ARRAY_IN_ARRAY: c_int = NPY_ARRAY_CARRAY_RO;
+pub const NPY_ARRAY_OUT_ARRAY: c_int = NPY_ARRAY_CARRAY;
+pub const NPY_ARRAY_INOUT_ARRAY: c_int = NPY_ARRAY_CARRAY | NPY_ARRAY_UPDATEIFCOPY;
+pub const NPY_ARRAY_INOUT_ARRAY2: c_int = NPY_ARRAY_CARRAY | NPY_ARRAY_WRITEBACKIFCOPY;
+pub const NPY_ARRAY_IN_FARRAY: c_int = NPY_ARRAY_FARRAY_RO;
+pub const NPY_ARRAY_OUT_FARRAY: c_int = NPY_ARRAY_FARRAY;
+pub const NPY_ARRAY_INOUT_FARRAY: c_int = NPY_ARRAY_FARRAY | NPY_ARRAY_UPDATEIFCOPY;
+pub const NPY_ARRAY_INOUT_FARRAY2: c_int = NPY_ARRAY_FARRAY | NPY_ARRAY_WRITEBACKIFCOPY;
+pub const NPY_ARRAY_UPDATE_ALL: c_int = NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_F_CONTIGUOUS;

src/npyffi/mod.rs

@@ -48,11 +48,13 @@ macro_rules! impl_api {
 }
 
 pub mod array;
+pub mod flags;
 pub mod objects;
 pub mod types;
 pub mod ufunc;
 
 pub use self::array::*;
+pub use self::flags::*;
 pub use self::objects::*;
 pub use self::types::*;
 pub use self::ufunc::*;