Switch from Dimension::SliceArg to CanSlice trait

Author: jturner314

src/dimension/dimension_trait.rs

@@ -13,7 +13,7 @@ use std::ops::{Add, Sub, Mul, AddAssign, SubAssign, MulAssign};
 
 use itertools::{enumerate, izip, zip};
 
-use {Ix, Ixs, Ix0, Ix1, Ix2, Ix3, Ix4, Ix5, Ix6, IxDyn, Dim, AxisSliceInfo, IxDynImpl};
+use {Ix, Ixs, Ix0, Ix1, Ix2, Ix3, Ix4, Ix5, Ix6, IxDyn, Dim, IxDynImpl};
 use IntoDimension;
 use RemoveAxis;
 use {ArrayView1, ArrayViewMut1};
@@ -45,21 +45,6 @@ pub trait Dimension : Clone + Eq + Debug + Send + Sync + Default +
     /// `Some(ndim)`, and for variable-size dimension representations (e.g.
     /// `IxDyn`), this should be `None`.
     const NDIM: Option<usize>;
-    /// `SliceArg` is the type which is used to specify slicing for this
-    /// dimension.
-    ///
-    /// For the fixed size dimensions it is a fixed size array of the correct
-    /// size, which you pass by reference. For the dynamic dimension it is
-    /// a slice.
-    ///
-    /// - For `Ix1`: `[AxisSliceInfo; 1]`
-    /// - For `Ix2`: `[AxisSliceInfo; 2]`
-    /// - and so on..
-    /// - For `IxDyn`: `[AxisSliceInfo]`
-    ///
-    /// The easiest way to create a `&SliceInfo<SliceArg, Do>` is using the
-    /// [`s![]`](macro.s!.html) macro.
-    type SliceArg: ?Sized + AsRef<[AxisSliceInfo]>;
     /// Pattern matching friendly form of the dimension value.
     ///
     /// - For `Ix1`: `usize`,
@@ -364,7 +349,6 @@ macro_rules! impl_insert_axis_array(
 
 impl Dimension for Dim<[Ix; 0]> {
     const NDIM: Option<usize> = Some(0);
-    type SliceArg = [AxisSliceInfo; 0];
     type Pattern = ();
     type Smaller = Self;
     type Larger = Ix1;
@@ -401,7 +385,6 @@ impl Dimension for Dim<[Ix; 0]> {
 
 impl Dimension for Dim<[Ix; 1]> {
     const NDIM: Option<usize> = Some(1);
-    type SliceArg = [AxisSliceInfo; 1];
     type Pattern = Ix;
     type Smaller = Ix0;
     type Larger = Ix2;
@@ -499,7 +482,6 @@ impl Dimension for Dim<[Ix; 1]> {
 
 impl Dimension for Dim<[Ix; 2]> {
     const NDIM: Option<usize> = Some(2);
-    type SliceArg = [AxisSliceInfo; 2];
     type Pattern = (Ix, Ix);
     type Smaller = Ix1;
     type Larger = Ix3;
@@ -645,7 +627,6 @@ impl Dimension for Dim<[Ix; 2]> {
 
 impl Dimension for Dim<[Ix; 3]> {
     const NDIM: Option<usize> = Some(3);
-    type SliceArg = [AxisSliceInfo; 3];
     type Pattern = (Ix, Ix, Ix);
     type Smaller = Ix2;
     type Larger = Ix4;
@@ -763,7 +744,6 @@ macro_rules! large_dim {
     ($n:expr, $name:ident, $pattern:ty, $larger:ty, { $($insert_axis:tt)* }) => (
         impl Dimension for Dim<[Ix; $n]> {
             const NDIM: Option<usize> = Some($n);
-            type SliceArg = [AxisSliceInfo; $n];
             type Pattern = $pattern;
             type Smaller = Dim<[Ix; $n - 1]>;
             type Larger = $larger;
@@ -815,7 +795,6 @@ large_dim!(6, Ix6, (Ix, Ix, Ix, Ix, Ix, Ix), IxDyn, {
 impl Dimension for IxDyn
 {
     const NDIM: Option<usize> = None;
-    type SliceArg = [AxisSliceInfo];
     type Pattern = Self;
     type Smaller = Self;
     type Larger = Self;

src/dimension/mod.rs

@@ -8,6 +8,7 @@
 
 use {AxisSliceInfo, Ix, Ixs, Slice};
 use error::{from_kind, ErrorKind, ShapeError};
+use slice::CanSlice;
 use itertools::izip;
 use num_integer::div_floor;
 
@@ -529,10 +530,10 @@ fn slice_min_max(axis_len: usize, slice: Slice) -> Option<(usize, usize)> {
 #[doc(hidden)]
 pub fn slices_intersect<D: Dimension>(
     dim: &D,
-    indices1: &D::SliceArg,
-    indices2: &D::SliceArg,
+    indices1: &impl CanSlice<D>,
+    indices2: &impl CanSlice<D>,
 ) -> bool {
-    debug_assert_eq!(indices1.as_ref().len(), indices2.as_ref().len());
+    debug_assert_eq!(indices1.in_ndim(), indices2.in_ndim());
     for (&axis_len, &si1, &si2) in izip!(dim.slice(), indices1.as_ref(), indices2.as_ref()) {
         // The slices do not intersect iff any pair of `AxisSliceInfo` does not intersect.
         match (si1, si2) {

src/impl_methods.rs

@@ -25,7 +25,6 @@ use {
     AxisSliceInfo,
     NdIndex,
     Slice,
-    SliceInfo,
 };
 use iter::{
     AxisChunksIter,
@@ -42,6 +41,7 @@ use iter::{
     ExactChunksMut,
     Windows
 };
+use slice::CanSlice;
 use stacking::stack;
 
 /// # Methods For All Array Types
@@ -303,9 +303,9 @@ where
     ///
     /// **Panics** if an index is out of bounds or step size is zero.<br>
     /// (**Panics** if `D` is `IxDyn` and `info` does not match the number of array axes.)
-    pub fn slice<Do>(&self, info: &SliceInfo<D::SliceArg, Do>) -> ArrayView<A, Do>
+    pub fn slice<I>(&self, info: &I) -> ArrayView<A, I::OutDim>
     where
-        Do: Dimension,
+        I: CanSlice<D>,
         S: Data,
     {
         self.view().slice_move(info)
@@ -321,9 +321,9 @@ where
     ///
     /// **Panics** if an index is out of bounds or step size is zero.<br>
     /// (**Panics** if `D` is `IxDyn` and `info` does not match the number of array axes.)
-    pub fn slice_mut<Do>(&mut self, info: &SliceInfo<D::SliceArg, Do>) -> ArrayViewMut<A, Do>
+    pub fn slice_mut<I>(&mut self, info: &I) -> ArrayViewMut<A, I::OutDim>
     where
-        Do: Dimension,
+        I: CanSlice<D>,
         S: DataMut,
     {
         self.view_mut().slice_move(info)
@@ -339,29 +339,37 @@ where
     ///
     /// **Panics** if an index is out of bounds or step size is zero.<br>
     /// (**Panics** if `D` is `IxDyn` and `info` does not match the number of array axes.)
-    pub fn slice_move<Do>(mut self, info: &SliceInfo<D::SliceArg, Do>) -> ArrayBase<S, Do>
+    pub fn slice_move<I>(mut self, info: &I) -> ArrayBase<S, I::OutDim>
     where
-        Do: Dimension,
+        I: CanSlice<D>,
     {
         // Slice and collapse in-place without changing the number of dimensions.
-        self.slice_collapse(&*info);
+        self.slice_collapse(info);
 
-        let indices: &[AxisSliceInfo] = (**info).as_ref();
-
-        // Copy the dim and strides that remain after removing the subview axes.
         let out_ndim = info.out_ndim();
-        let mut new_dim = Do::zeros(out_ndim);
-        let mut new_strides = Do::zeros(out_ndim);
-        izip!(self.dim.slice(), self.strides.slice(), indices)
-            .filter_map(|(d, s, slice_or_index)| match slice_or_index {
-                &AxisSliceInfo::Slice {..} => Some((d, s)),
-                &AxisSliceInfo::Index(_) => None,
-            })
-            .zip(izip!(new_dim.slice_mut(), new_strides.slice_mut()))
-            .for_each(|((d, s), (new_d, new_s))| {
-                *new_d = *d;
-                *new_s = *s;
+        let mut new_dim = I::OutDim::zeros(out_ndim);
+        let mut new_strides = I::OutDim::zeros(out_ndim);
+
+        // Write the dim and strides to the correct new axes.
+        {
+            let mut old_axis = 0;
+            let mut new_axis = 0;
+            info.as_ref().iter().for_each(|ax_info| match ax_info {
+                &AxisSliceInfo::Slice { .. } => {
+                    // Copy the old dim and stride to corresponding axis.
+                    new_dim[new_axis] = self.dim[old_axis];
+                    new_strides[new_axis] = self.strides[old_axis];
+                    old_axis += 1;
+                    new_axis += 1;
+                }
+                &AxisSliceInfo::Index(_) => {
+                    // Skip the old axis since it should be removed.
+                    old_axis += 1;
+                }
             });
+            debug_assert_eq!(old_axis, self.ndim());
+            debug_assert_eq!(new_axis, out_ndim);
+        }
 
         ArrayBase {
             ptr: self.ptr,
@@ -373,25 +381,23 @@ where
 
     /// Slice the array in place without changing the number of dimensions.
     ///
-    /// Note that [`&SliceInfo`](struct.SliceInfo.html) (produced by the
-    /// [`s![]`](macro.s!.html) macro) will usually coerce into `&D::SliceArg`
-    /// automatically, but in some cases (e.g. if `D` is `IxDyn`), you may need
-    /// to call `.as_ref()`.
-    ///
     /// See [*Slicing*](#slicing) for full documentation.
-    /// See also [`D::SliceArg`].
-    ///
-    /// [`D::SliceArg`]: trait.Dimension.html#associatedtype.SliceArg
     ///
     /// **Panics** if an index is out of bounds or step size is zero.<br>
-    /// (**Panics** if `D` is `IxDyn` and `indices` does not match the number of array axes.)
-    pub fn slice_collapse(&mut self, indices: &D::SliceArg) {
-        let indices: &[AxisSliceInfo] = indices.as_ref();
-        assert_eq!(indices.len(), self.ndim());
-        indices
+    /// (**Panics** if `D` is `IxDyn` and `info` does not match the number of array axes.)
+    pub fn slice_collapse<I>(&mut self, info: &I)
+    where
+        I: CanSlice<D>,
+    {
+        assert_eq!(
+            info.in_ndim(),
+            self.ndim(),
+            "The input dimension of `info` must match the array to be sliced.",
+        );
+        info.as_ref()
             .iter()
             .enumerate()
-            .for_each(|(axis, slice_or_index)| match slice_or_index {
+            .for_each(|(axis, ax_info)| match ax_info {
                 &AxisSliceInfo::Slice { start, end, step } => {
                     self.slice_axis_inplace(Axis(axis), Slice { start, end, step })
                 }
@@ -407,7 +413,10 @@ where
     /// **Panics** if an index is out of bounds or step size is zero.<br>
     /// (**Panics** if `D` is `IxDyn` and `indices` does not match the number of array axes.)
     #[deprecated(note="renamed to `slice_collapse`", since="0.12.1")]
-    pub fn slice_inplace(&mut self, indices: &D::SliceArg) {
+    pub fn slice_inplace<I>(&mut self, indices: &I)
+    where
+        I: CanSlice<D>,
+    {
         self.slice_collapse(indices)
     }
 

src/lib.rs

@@ -127,7 +127,7 @@ pub use indexes::{indices, indices_of};
 pub use error::{ShapeError, ErrorKind};
 pub use slice::{
     deref_raw_view_mut_into_view_with_life, deref_raw_view_mut_into_view_mut_with_life,
-    life_of_view_mut, AxisSliceInfo, Slice, SliceInfo, SliceNextDim,
+    life_of_view_mut, AxisSliceInfo, Slice, SliceInfo, SliceNextInDim, SliceNextOutDim,
 };
 
 use iterators::Baseiter;