As standard layout method

src/data_traits.rs

@@ -16,6 +16,7 @@ use crate::{
     Dimension,
     RawViewRepr,
     ViewRepr,
+    CowRepr,
     OwnedRepr,
     OwnedRcRepr,
     OwnedArcRepr,
@@ -412,3 +413,85 @@ unsafe impl<A> DataOwned for OwnedArcRepr<A> {
         self
     }
 }
+
+unsafe impl<'a, A> RawData for CowRepr<'a, A>
+    where A: Clone
+{
+    type Elem = A;
+    fn _data_slice(&self) -> Option<&[A]> {
+        match self {
+            CowRepr::View(view) => view._data_slice(),
+            CowRepr::Owned(data) => data._data_slice(),
+        }
+    }
+    private_impl!{}
+}
+
+unsafe impl<'a, A> RawDataMut for CowRepr<'a, A>
+    where A: Clone
+{
+    #[inline]
+    fn try_ensure_unique<D>(array: &mut ArrayBase<Self, D>)
+        where Self: Sized,
+              D: Dimension
+    {
+        array.ensure_is_owned();
+    }
+
+    #[inline]
+    fn try_is_unique(&mut self) -> Option<bool> {
+        Some(self.is_owned())
+    }
+}
+
+unsafe impl<'a, A> RawDataClone for CowRepr<'a, A>
+    where A: Copy
+{
+    unsafe fn clone_with_ptr(&self, ptr: *mut Self::Elem) -> (Self, *mut Self::Elem) {
+        match self {
+            CowRepr::View(view) => {
+                let (new_view, ptr) = view.clone_with_ptr(ptr);
+                (CowRepr::View(new_view), ptr)
+            },
+            CowRepr::Owned(data) => {
+                let (new_data, ptr) = data.clone_with_ptr(ptr);
+                (CowRepr::Owned(new_data), ptr)
+            },
+        }
+    }
+
+    #[doc(hidden)]
+    unsafe fn clone_from_with_ptr(&mut self, other: &Self, ptr: *mut Self::Elem) -> *mut Self::Elem {
+        match self {
+            CowRepr::View(view) => {
+                match other {
+                    CowRepr::View(other_view) => view.clone_from_with_ptr(other_view, ptr),
+                    CowRepr::Owned(_) => panic!("Cannot copy `CowRepr::View` from `CowRepr::Temp`"),
+                }
+            },
+            CowRepr::Owned(data) => {
+                match other {
+                    CowRepr::View(_) => panic!("Cannot copy `CowRepr::Temp` from `CowRepr::View`"),
+                    CowRepr::Owned(other_data) => data.clone_from_with_ptr(other_data, ptr),
+                }
+            },
+        }
+    }
+}
+
+unsafe impl<'a, A> Data for CowRepr<'a, A>
+    where A: Clone
+{
+    #[inline]
+    fn into_owned<D>(self_: ArrayBase<CowRepr<'a, A>, D>) -> ArrayBase<OwnedRepr<Self::Elem>, D>
+        where
+            A: Clone,
+            D: Dimension,
+    {
+        if self_.data.is_view() {
+            ViewRepr::into_owned(self_.into_view_array().unwrap())
+        } else {
+            OwnedRepr::into_owned(self_.into_owned_array().unwrap())
+        }
+    }
+}

src/impl_methods.rs

@@ -14,7 +14,7 @@ use itertools::{izip, zip};
 
 use crate::imp_prelude::*;
 
-use crate::arraytraits;
+use crate::{arraytraits, ArrayCow};
 use crate::dimension;
 use crate::error::{self, ShapeError, ErrorKind};
 use crate::dimension::IntoDimension;
@@ -1225,6 +1225,22 @@ where
         D::is_contiguous(&self.dim, &self.strides)
     }
 
+    pub fn as_standard_layout(&self) -> ArrayCow<'_, A, D>
+        where S: Data<Elem=A>,
+              A: Clone
+    {
+        if self.is_standard_layout() {
+            ArrayCow::from_view_array(self.view())
+        } else {
+            let v = self.iter().map(|x| x.clone()).collect::<Vec<A>>();
+            let owned_array: Array<A, D> = unsafe {
+                // Safe because we use shape and content of existing array here.
+                ArrayBase::from_shape_vec_unchecked(self.dim(), v)
+            };
+            ArrayCow::from_owned_array(owned_array)
+        }
+    }
+
     /// Return a pointer to the first element in the array.
     ///
     /// Raw access to array elements needs to follow the strided indexing

src/lib.rs

@@ -1374,6 +1374,30 @@ impl<A> ViewRepr<A> {
     }
 }
 
+pub enum CowRepr<'a, A>
+    where A: Clone
+{
+    View(ViewRepr<&'a A>),
+    Owned(OwnedRepr<A>),
+}
+
+impl<'a, A> CowRepr<'a, A>
+    where A: Clone
+{
+    pub fn is_view(&self) -> bool {
+        match self {
+            CowRepr::View(_) => true,
+            CowRepr::Owned(_) => false,
+        }
+    }
+
+    pub fn is_owned(&self) -> bool {
+        !self.is_view()
+    }
+}
+
+pub type ArrayCow<'a, A, D> = ArrayBase<CowRepr<'a, A>, D>;
+
 mod impl_clone;
 
 mod impl_constructors;
@@ -1472,6 +1496,69 @@ impl<A, S, D> ArrayBase<S, D>
     }
 }
 
+impl<'a, A, D> ArrayCow<'a, A, D>
+    where A: Clone,
+          D: Dimension
+{
+    fn from_view_array(array: ArrayView<'a, A, D>) -> ArrayCow<'a, A, D> {
+        ArrayBase {
+            data: CowRepr::View(array.data),
+            ptr: array.ptr,
+            dim: array.dim,
+            strides: array.strides,
+        }
+    }
+
+    fn from_owned_array(array: Array<A, D>) -> ArrayCow<'a, A, D> {
+        ArrayBase {
+            data: CowRepr::Owned(array.data),
+            ptr: array.ptr,
+            dim: array.dim,
+            strides: array.strides,
+        }
+    }
+
+    fn into_view_array(self) -> Option<ArrayView<'a, A, D>> {
+        match self.data {
+            CowRepr::View(view) => Some(ArrayBase {
+                data: view,
+                ptr: self.ptr,
+                dim: self.dim,
+                strides: self.strides,
+            }),
+            CowRepr::Owned(_) => None,
+        }
+    }
+
+    fn into_owned_array(self) -> Option<Array<A, D>> {
+        match self.data {
+            CowRepr::View(_) => None,
+            CowRepr::Owned(data) => Some(ArrayBase {
+                data,
+                ptr: self.ptr,
+                dim: self.dim,
+                strides: self.strides,
+            })
+        }
+    }
+
+    fn ensure_is_owned(&mut self) {
+        if self.data.is_view() {
+            let mut copied_data: Vec<A> = self.iter().map(|x| x.clone()).collect();
+            self.ptr = copied_data.as_mut_ptr();
+            self.data = CowRepr::Owned(OwnedRepr(copied_data));
+        }
+    }
+
+    pub fn is_view(&self) -> bool {
+        self.data.is_view()
+    }
+
+    pub fn is_owned(&self) -> bool {
+        self.data.is_owned()
+    }
+}
+
 
 // parallel methods
 #[cfg(feature="rayon")]

tests/array.rs

@@ -4,7 +4,7 @@ extern crate ndarray;
 extern crate defmac;
 extern crate itertools;
 
-use ndarray::{Slice, SliceInfo, SliceOrIndex};
+use ndarray::{Slice, SliceInfo, SliceOrIndex, Data};
 use ndarray::prelude::*;
 use ndarray::{
     rcarr2,
@@ -1891,3 +1891,66 @@ fn array_macros() {
     let empty2: Array<f32, Ix2> = array![[]];
     assert_eq!(empty2, array![[]]);
 }
+
+#[test]
+fn test_as_contiguous() {
+    fn is_content_identical<A, S1, S2, D>(arr1: &ArrayBase<S1, D>, arr2: &ArrayBase<S2, D>) -> bool
+        where A: Clone + PartialEq,
+              S1: Data<Elem=A>,
+              S2: Data<Elem=A>,
+              D: Dimension
+    {
+        arr1.iter().zip(arr2.iter()).all(|(x1, x2)| x1 == x2)
+    }
+
+    // F layout
+    let shape = Ix2(2, 2).strides(Ix2(1, 2));
+    let arr = Array::<i32, Ix2>::from_shape_vec(shape, vec![1, 2, 3, 4]).unwrap();
+    assert!(!arr.is_standard_layout());
+    let cont_arr = arr.as_standard_layout();
+    assert!(cont_arr.is_standard_layout());
+    assert!(is_content_identical(&arr, &cont_arr));
+    assert!(cont_arr.is_owned());
+
+    // C layout
+    let arr = Array::<i32, Ix2>::from_shape_vec((2, 2), vec![1, 2, 3, 4]).unwrap();
+    assert!(arr.is_standard_layout());
+    let cont_arr = arr.as_standard_layout();
+    assert!(cont_arr.is_standard_layout());
+    assert!(is_content_identical(&arr, &cont_arr));
+    assert!(cont_arr.is_view());
+
+    // F layout view
+    let shape = Ix2(2, 2).strides(Ix2(1, 2));
+    let arr = Array::<i32, Ix2>::from_shape_vec(shape, vec![1, 2, 3, 4]).unwrap();
+    let arr_view = arr.view();
+    assert!(!arr_view.is_standard_layout());
+    let cont_arr = arr.as_standard_layout();
+    assert!(cont_arr.is_standard_layout());
+    assert!(is_content_identical(&arr, &cont_arr));
+    assert!(cont_arr.is_owned());
+
+    // C layout view
+    let arr = Array::<i32, Ix2>::from_shape_vec((2, 2), vec![1, 2, 3, 4]).unwrap();
+    let arr_view = arr.view();
+    assert!(arr_view.is_standard_layout());
+    let cont_arr = arr_view.as_standard_layout();
+    assert!(is_content_identical(&arr, &cont_arr));
+    assert!(cont_arr.is_view());
+
+    // 0 dimensional array
+    let arr_view = ArrayView1::<i32>::from(&[]);
+    assert!(arr_view.is_standard_layout());
+    let cont_arr = arr_view.as_standard_layout();
+    assert!(is_content_identical(&arr_view, &cont_arr));
+    assert!(cont_arr.is_view());
+
+    // Custom layout
+    let shape = Ix4(1, 2, 3, 2).strides(Ix4(12, 1, 2, 6));
+    let arr_data: Vec<i32> = (0..12).collect();
+    let arr = Array::<i32, Ix4>::from_shape_vec(shape, arr_data).unwrap();
+    assert!(!arr.is_standard_layout());
+    let cont_arr = arr.as_standard_layout();
+    assert!(is_content_identical(&arr, &cont_arr));
+    assert!(cont_arr.is_owned());
+}