Use new function flatview instead of Base.parent to access flattened view

Author: oschulz

src/array_of_similar_arrays.jl

@@ -5,11 +5,11 @@
 
 An array that contains arrays that have the same size/axes. The array is
 internally stored in flattened form as some kind of array of dimension
-`M + N`. The flattened form can be accessed via `parent(A)`.
+`M + N`. The flattened form can be accessed via `flatview(A)`.
 
 Subtypes must implement (in addition to typical array operations):
 
-    parent(A::SomeArrayOfSimilarArrays)::AbstractArray{T,M+N}
+    flatview(A::SomeArrayOfSimilarArrays)::AbstractArray{T,M+N}
 
 The following type aliases are defined:
 
@@ -40,7 +40,7 @@ implicitly have equal size/axes.
 
 Constructors:
 
-    ArrayOfSimilarArrays{N}(parent::AbstractArray)
+    ArrayOfSimilarArrays{N}(flatview::AbstractArray)
 
 The following type aliases are defined:
 
@@ -57,10 +57,10 @@ struct ArrayOfSimilarArrays{
 } <: AbstractArrayOfSimilarArrays{T,M,N}
     data::P
 
-    function ArrayOfSimilarArrays{T,M,N}(parent::AbstractArray{U,L}) where {T,M,N,L,U}
-        size_inner, size_outer = split_tuple(size(parent), Val{M}())
-        require_ndims(parent, _add_vals(Val{M}(), Val{N}()))
-        conv_parent = _convert_elype(T, parent)
+    function ArrayOfSimilarArrays{T,M,N}(flatview::AbstractArray{U,L}) where {T,M,N,L,U}
+        size_inner, size_outer = split_tuple(size(flatview), Val{M}())
+        require_ndims(flatview, _add_vals(Val{M}(), Val{N}()))
+        conv_parent = _convert_elype(T, flatview)
         P = typeof(conv_parent)
         new{T,M,N,L,P}(conv_parent)
     end
@@ -80,7 +80,7 @@ ArrayOfSimilarArrays(A::AbstractArray{<:AbstractArray{T,M},N}) where {T,M,N} =
     ArrayOfSimilarArrays{T,M,N}(A)
 
 
-Base.convert(R::Type{ArrayOfSimilarArrays{T,M,N}}, parent::AbstractArray{U,L}) where {T,M,N,L,U} = R(parent)
+Base.convert(R::Type{ArrayOfSimilarArrays{T,M,N}}, flatview::AbstractArray{U,L}) where {T,M,N,L,U} = R(flatview)
 
 Base.convert(R::Type{ArrayOfSimilarArrays{T,M,N}}, A::AbstractArray{<:AbstractArray{U,M},N}) where {T,M,N,U} = R(A)
 Base.convert(R::Type{ArrayOfSimilarArrays{T}}, A::AbstractArray{<:AbstractArray{U,M},N}) where {T,M,N,U} = R(A)
@@ -114,7 +114,14 @@ import Base.==
     (A.data == B.data)
 
 
-Base.parent(A::ArrayOfSimilarArrays) = A.data
+"""
+    flatview(A::ArrayOfSimilarArrays{T,M,N,L,P})::P
+
+Returns the array of dimensionality `L = M + N` wrapped by `A`. The shape of
+the result may be freely changed without breaking the inner consistency of
+`A`.
+"""
+flatview(A::ArrayOfSimilarArrays) = A.data
 
 
 Base.size(A::ArrayOfSimilarArrays{T,M,N}) where {T,M,N} = split_tuple(size(A.data), Val{M}())[2]
@@ -196,8 +203,8 @@ const VectorOfSimilarArrays{
 
 export VectorOfSimilarArrays
 
-VectorOfSimilarArrays{T}(parent::AbstractArray{U,L}) where {T,U,L} =
-    ArrayOfSimilarArrays{T,length(Base.front(size(parent))),1}(parent)
+VectorOfSimilarArrays{T}(flatview::AbstractArray{U,L}) where {T,U,L} =
+    ArrayOfSimilarArrays{T,length(Base.front(size(flatview))),1}(flatview)
 
 VectorOfSimilarArrays{T}(A::AbstractVector{<:AbstractArray{U,M}}) where {T,M,U} =
     VectorOfSimilarArrays{T,M}(A)
@@ -206,7 +213,7 @@ VectorOfSimilarArrays(A::AbstractVector{<:AbstractArray{T,M}}) where {T,M} =
     VectorOfSimilarArrays{T,M}(A)
 
 
-Base.convert(R::Type{VectorOfSimilarArrays{T}}, parent::AbstractArray{U,L}) where {T,U,L} = R(parent)
+Base.convert(R::Type{VectorOfSimilarArrays{T}}, flatview::AbstractArray{U,L}) where {T,U,L} = R(flatview)
 Base.convert(R::Type{VectorOfSimilarArrays{T}}, A::AbstractVector{<:AbstractArray{U,M}}) where {T,M,U} = R(A)
 Base.convert(R::Type{VectorOfSimilarArrays}, A::AbstractVector{<:AbstractArray{T,M}}) where {T,M} = R(A)
 
@@ -245,8 +252,8 @@ const ArrayOfSimilarVectors{
 
 export ArrayOfSimilarVectors
 
-ArrayOfSimilarVectors{T}(parent::AbstractArray{U,L}) where {T,U,L} =
-    ArrayOfSimilarArrays{T,1,length(Base.front(size(parent)))}(parent)
+ArrayOfSimilarVectors{T}(flatview::AbstractArray{U,L}) where {T,U,L} =
+    ArrayOfSimilarArrays{T,1,length(Base.front(size(flatview)))}(flatview)
 
 ArrayOfSimilarVectors{T}(A::AbstractArray{<:AbstractVector{U},N}) where {T,N,U} =
     ArrayOfSimilarVectors{T,N}(A)
@@ -255,7 +262,7 @@ ArrayOfSimilarVectors(A::AbstractArray{<:AbstractVector{T},N}) where {T,N} =
     ArrayOfSimilarVectors{T,N}(A)
 
 
-Base.convert(R::Type{ArrayOfSimilarVectors{T}}, parent::AbstractArray{U,L}) where {T,U,L} = R(parent)
+Base.convert(R::Type{ArrayOfSimilarVectors{T}}, flatview::AbstractArray{U,L}) where {T,U,L} = R(flatview)
 Base.convert(R::Type{ArrayOfSimilarVectors{T}}, A::AbstractArray{<:AbstractVector{U},N}) where {T,N,U} = R(A)
 Base.convert(R::Type{ArrayOfSimilarVectors}, A::AbstractArray{<:AbstractVector{T},N}) where {T,N} = R(A)
 
@@ -299,20 +306,20 @@ const VectorOfSimilarVectors{
 
 export VectorOfSimilarVectors
 
-VectorOfSimilarVectors{T}(parent::AbstractArray{U,2}) where {T,U} =
-    ArrayOfSimilarArrays{T,1,1}(parent)
+VectorOfSimilarVectors{T}(flatview::AbstractArray{U,2}) where {T,U} =
+    ArrayOfSimilarArrays{T,1,1}(flatview)
 
-VectorOfSimilarVectors(parent::AbstractArray{T,2}) where {T} =
-    VectorOfSimilarVectors{T}(parent)
+VectorOfSimilarVectors(flatview::AbstractArray{T,2}) where {T} =
+    VectorOfSimilarVectors{T}(flatview)
 
 VectorOfSimilarVectors{T}(A::AbstractVector{<:AbstractVector{U}}) where {T,U} =
     ArrayOfSimilarArrays{T,1}(A)
 
 VectorOfSimilarVectors(A::AbstractVector{<:AbstractVector{T}}) where {T} =
     VectorOfSimilarVectors{T}(A)
 
-Base.convert(R::Type{VectorOfSimilarVectors{T}}, parent::AbstractArray{U,2}) where {T,U} = R(parent)
-Base.convert(R::Type{VectorOfSimilarVectors}, parent::AbstractArray{T,2}) where {T} = R(parent)
+Base.convert(R::Type{VectorOfSimilarVectors{T}}, flatview::AbstractArray{U,2}) where {T,U} = R(flatview)
+Base.convert(R::Type{VectorOfSimilarVectors}, flatview::AbstractArray{T,2}) where {T} = R(flatview)
 Base.convert(R::Type{VectorOfSimilarVectors{T}}, A::AbstractVector{<:AbstractVector{U}}) where {T,U} = R(A)
 Base.convert(R::Type{VectorOfSimilarVectors}, A::AbstractVector{<:AbstractVector{T}}) where {T} = R(A)
 

src/functions.jl

@@ -27,3 +27,20 @@ deepmap(f::Base.Callable, x::Any) = map(f, x)
 
 deepmap(f::Base.Callable, A::AbstractArray{<:AbstractArray}) =
     map(X -> deepmap(f, X), A)
+
+
+"""
+    flatview(A::AbstractArray)
+    flatview(A::AbstractArray{<:AbstractArray{<:...}})
+
+View array `A` in a suitable flattened form. The shape of the flattened form
+will depend on the type of `A`. If the `A` is not a nested array, the return
+value is `A` itself. When no type-specific method is available, `flatview`
+will fall back to `Base.Iterators.flatten`.
+"""
+function flatview end
+export flatview
+
+flatview(A::AbstractArray) = A
+
+flatview(A::AbstractArray{<:AbstractArray}) = Base.Iterators.flatten(A)

src/vector_of_arrays.jl

@@ -137,8 +137,14 @@ import Base.==
 (==)(A::VectorOfArrays, B::VectorOfArrays) =
     A.data == B.data && A.elem_ptr == B.elem_ptr && A.kernel_size == B.kernel_size
 
+"""
+    flatview(A::VectorOfArrays{T})::Vector{T}
 
-Base.parent(A::VectorOfArrays) = A.data
+Returns the internal serialized representation of all element arrays of `A` as
+a single vector. Do *not* change the length of the returned vector, as it
+would break the inner consistency of `A`.
+"""
+flatview(A::VectorOfArrays) = A.data
 
 Base.size(A::VectorOfArrays) = size(A.kernel_size)
 

test/array_of_similar_arrays.jl

@@ -50,7 +50,7 @@ using UnsafeArrays
             A = rand_nested_similar_arrays(Val_M, Val_N)
 
             A2_ctor = @inferred TT(A)
-            U = eltype(parent(A2_ctor))
+            U = eltype(flatview(A2_ctor))
 
             A_U = Array{Array{U,M},N}(A)
 
@@ -61,7 +61,7 @@ using UnsafeArrays
             @test typeof(A2_conv) == RT
             @test A2_conv == A2_ctor
 
-            U = eltype(parent(A2_ctor))
+            U = eltype(flatview(A2_ctor))
             A3 = @inferred Array(A2_ctor)
             @test typeof(A3) == Array{Array{U,M},N}
             @test A3 == A_U