Transfer function into SliceInfo; Use Result as the return value

rust-ndarray · SparrowLii · Feb 3, 2021 · Feb 4, 2021 · Feb 5, 2021 · Feb 5, 2021
commit 03c379165477b99b08b38f221d96c03c6519793d
diff --git a/src/dimension/dimension_trait.rs b/src/dimension/dimension_trait.rs
@@ -16,7 +16,7 @@ use super::axes_of;
 use super::conversion::Convert;
 use super::{stride_offset, stride_offset_checked};
 use crate::itertools::{enumerate, zip};
-use crate::{Axis, SliceInfo};
+use crate::{Axis, ShapeError, ErrorKind};
 use crate::IntoDimension;
 use crate::RemoveAxis;
 use crate::{ArrayView1, ArrayViewMut1};
@@ -78,35 +78,6 @@ pub trait Dimension:
     type Smaller: Dimension;
     /// Next larger dimension
     type Larger: Dimension + RemoveAxis;
-
-    /// Convert index to &Self::SliceArg. Make sure that length of index
-    /// consists with Self::NDIM(if it exists).
-    ///
-    /// Panics if conversion failed.
-    #[doc(hidden)]
-    fn slice_arg_from(index: &[SliceOrIndex]) -> &Self::SliceArg ;
-
-    /// Convert &SliceInfo<AsRef<[SliceOrIndex]>, Do> to &SliceInfo<D::SliceArg, Do>.
-    /// Generate SliceArg of any dimension via this method.
-    ///
-    /// Panics if conversion failed.
-    #[doc(hidden)]
-    fn slice_info_from<T, Do>(indices: &T) -> &SliceInfo<Self::SliceArg, Do>
-    where
-        T: AsRef<[SliceOrIndex]>,
-        Do: Dimension,
-    {
-        let arg_ref = Self::slice_arg_from(indices.as_ref());
-        unsafe {
-            // This is okay because the only non-zero-sized member of
-            // `SliceInfo` is `indices`, so `&SliceInfo<[SliceOrIndex], D>`
-            // should have the same bitwise representation as
-            // `&[SliceOrIndex]`.
-            &*(arg_ref as *const Self::SliceArg
-                as *const SliceInfo<Self::SliceArg, Do>)
-        }
-    }
-
     /// Returns the number of dimensions (number of axes).
     fn ndim(&self) -> usize;
 
@@ -404,6 +375,11 @@ pub trait Dimension:
     #[doc(hidden)]
     fn try_remove_axis(&self, axis: Axis) -> Self::Smaller;
 
+    /// Convert index to &Self::SliceArg. Return ShapeError if the length of index
+    /// doesn't consist with Self::NDIM(if it exists).
+    #[doc(hidden)]
+    fn slice_arg_from<T: AsRef<[SliceOrIndex]>>(index: &T) -> Result<&Self::SliceArg, ShapeError>;
+
     private_decl! {}
 }
 
@@ -427,10 +403,6 @@ impl Dimension for Dim<[Ix; 0]> {
     type Pattern = ();
     type Smaller = Self;
     type Larger = Ix1;
-    #[inline]
-    fn slice_arg_from(index: &[SliceOrIndex]) -> &Self::SliceArg {
-        index.try_into().unwrap()
-    }
     // empty product is 1 -> size is 1
     #[inline]
     fn ndim(&self) -> usize {
@@ -465,6 +437,13 @@ impl Dimension for Dim<[Ix; 0]> {
     fn try_remove_axis(&self, _ignore: Axis) -> Self::Smaller {
         *self
     }
+    #[inline]
+    fn slice_arg_from<T: AsRef<[SliceOrIndex]>>(index: &T) -> Result<&Self::SliceArg, ShapeError> {
+        match index.as_ref().try_into() {
+            Ok(arg) => Ok(arg),
+            Err(_) => Err(ShapeError::from_kind(ErrorKind::IncompatibleShape))
+        }
+    }
 
     private_impl! {}
 }
@@ -475,9 +454,6 @@ impl Dimension for Dim<[Ix; 1]> {
     type Pattern = Ix;
     type Smaller = Ix0;
     type Larger = Ix2;
-    fn slice_arg_from(index: &[SliceOrIndex]) -> &Self::SliceArg {
-        index.try_into().unwrap()
-    }
     #[inline]
     fn ndim(&self) -> usize {
         1
@@ -585,6 +561,15 @@ impl Dimension for Dim<[Ix; 1]> {
             None
         }
     }
+
+    #[inline]
+    fn slice_arg_from<T: AsRef<[SliceOrIndex]>>(index: &T) -> Result<&Self::SliceArg, ShapeError> {
+        match index.as_ref().try_into() {
+            Ok(arg) => Ok(arg),
+            Err(_) => Err(ShapeError::from_kind(ErrorKind::IncompatibleShape))
+        }
+    }
+
     private_impl! {}
 }
 
@@ -594,9 +579,6 @@ impl Dimension for Dim<[Ix; 2]> {
     type Pattern = (Ix, Ix);
     type Smaller = Ix1;
     type Larger = Ix3;
-    fn slice_arg_from(index: &[SliceOrIndex]) -> &Self::SliceArg {
-        index.try_into().unwrap()
-    }
     #[inline]
     fn ndim(&self) -> usize {
         2
@@ -745,6 +727,13 @@ impl Dimension for Dim<[Ix; 2]> {
     fn try_remove_axis(&self, axis: Axis) -> Self::Smaller {
         self.remove_axis(axis)
     }
+    #[inline]
+    fn slice_arg_from<T: AsRef<[SliceOrIndex]>>(index: &T) -> Result<&Self::SliceArg, ShapeError> {
+        match index.as_ref().try_into() {
+            Ok(arg) => Ok(arg),
+            Err(_) => Err(ShapeError::from_kind(ErrorKind::IncompatibleShape))
+        }
+    }
     private_impl! {}
 }
 
@@ -754,9 +743,6 @@ impl Dimension for Dim<[Ix; 3]> {
     type Pattern = (Ix, Ix, Ix);
     type Smaller = Ix2;
     type Larger = Ix4;
-    fn slice_arg_from(index: &[SliceOrIndex]) -> &Self::SliceArg {
-        index.try_into().unwrap()
-    }
     #[inline]
     fn ndim(&self) -> usize {
         3
@@ -869,6 +855,13 @@ impl Dimension for Dim<[Ix; 3]> {
     fn try_remove_axis(&self, axis: Axis) -> Self::Smaller {
         self.remove_axis(axis)
     }
+    #[inline]
+    fn slice_arg_from<T: AsRef<[SliceOrIndex]>>(index: &T) -> Result<&Self::SliceArg, ShapeError> {
+        match index.as_ref().try_into() {
+            Ok(arg) => Ok(arg),
+            Err(_) => Err(ShapeError::from_kind(ErrorKind::IncompatibleShape))
+        }
+    }
     private_impl! {}
 }
 
@@ -880,9 +873,6 @@ macro_rules! large_dim {
             type Pattern = $pattern;
             type Smaller = Dim<[Ix; $n - 1]>;
             type Larger = $larger;
-            fn slice_arg_from(index: &[SliceOrIndex]) -> &Self::SliceArg {
-                index.try_into().unwrap()
-            }
             #[inline]
             fn ndim(&self) -> usize { $n }
             #[inline]
@@ -904,6 +894,13 @@ macro_rules! large_dim {
             fn try_remove_axis(&self, axis: Axis) -> Self::Smaller {
                 self.remove_axis(axis)
             }
+            #[inline]
+            fn slice_arg_from<T: AsRef<[SliceOrIndex]>>(index: &T) -> Result<&Self::SliceArg, ShapeError> {
+                match index.as_ref().try_into() {
+                    Ok(arg) => Ok(arg),
+                    Err(_) => Err(ShapeError::from_kind(ErrorKind::IncompatibleShape))
+                }
+            }
             private_impl!{}
         }
     )
@@ -934,9 +931,6 @@ impl Dimension for IxDyn {
     type Pattern = Self;
     type Smaller = Self;
     type Larger = Self;
-    fn slice_arg_from(index: &[SliceOrIndex]) -> &Self::SliceArg {
-        index
-    }
     #[inline]
     fn ndim(&self) -> usize {
         self.ix().len()
@@ -977,6 +971,10 @@ impl Dimension for IxDyn {
     fn from_dimension<D2: Dimension>(d: &D2) -> Option<Self> {
         Some(IxDyn(d.slice()))
     }
+    #[inline]
+    fn slice_arg_from<T: AsRef<[SliceOrIndex]>>(index: &T) -> Result<&Self::SliceArg, ShapeError> {
+        Ok(index.as_ref())
+    }
     private_impl! {}
 }
 

diff --git a/src/slice.rs b/src/slice.rs
@@ -333,6 +333,23 @@ where
             indices,
         })
     }
+
+    /// Generate the corresponding SliceInfo from AsRef<[SliceOrIndex]>
+    /// for the specific dimension E.
+    ///
+    /// Return ShapeError if length does not match
+    pub fn for_dimensionality<E: Dimension>(indices: &T) -> Result<&SliceInfo<E::SliceArg, D>, ShapeError>
+    {
+        let arg_ref = E::slice_arg_from(indices)?;
+        unsafe {
+            // This is okay because the only non-zero-sized member of
+            // `SliceInfo` is `indices`, so `&SliceInfo<[SliceOrIndex], D>`
+            // should have the same bitwise representation as
+            // `&[SliceOrIndex]`.
+            Ok(&*(arg_ref as *const E::SliceArg
+                as *const SliceInfo<E::SliceArg, D>))
+        }
+    }
 }
 
 impl<T: ?Sized, D> SliceInfo<T, D>

diff --git a/tests/array.rs b/tests/array.rs
@@ -285,14 +285,14 @@ fn test_slice_arg() {
         let mut x = Array::from_elem(shape, 0);
         let indices = x.shape().iter().map(f).collect::<Vec<_>>();
         let s = x.slice_mut(
-            <Sh::Dim as Dimension>::slice_info_from::<_, Sh::Dim>(&indices)
+            SliceInfo::<_, Sh::Dim>::for_dimensionality::<Sh::Dim>(&indices).unwrap()
         );
         let s2 = shape2.slice();
         assert_eq!(s.shape(), s2)
     }
-    use_arg_map(0,|x| SliceOrIndex::from(*x/2..*x),Dim([0]));
-    use_arg_map((2, 4, 8),|x| SliceOrIndex::from(*x/2..*x),Dim([1, 2, 4]));
-    use_arg_map(vec![3, 6, 9],|x| SliceOrIndex::from(*x/3..*x/2),Dim([0, 1, 1]));
+    use_arg_map(0, |x| SliceOrIndex::from(*x/2..*x),Dim([0]));
+    use_arg_map((2, 4, 8), |x| SliceOrIndex::from(*x/2..*x),Dim([1, 2, 4]));
+    use_arg_map(vec![3, 6, 9], |x| SliceOrIndex::from(*x/3..*x/2),Dim([0, 1, 1]));
     use_arg_map(vec![1, 2, 3, 4, 5, 6, 7], |x| SliceOrIndex::from(x-1), Dim([]));
 }