add missing methods for indexedtables (#36)

* add convert method for StructVector

* rename to default_array

Author: Pietro Vertechi

src/StructArrays.jl

@@ -18,7 +18,7 @@ function __init__()
     end
     Requires.@require WeakRefStrings="ea10d353-3f73-51f8-a26c-33c1cb351aa5" begin
         isstringarray(::WeakRefStrings.StringArray) = true
-        arrayof(::Type{T}, d) where {T<:AbstractString} = WeakRefStrings.StringArray{T}(d)
+        default_array(::Type{T}, d) where {T<:Union{AbstractString, Missing}} = WeakRefStrings.StringArray{T}(d)
     end
 end
 

src/collect.jl

@@ -1,25 +1,26 @@
-arrayof(S, d) = Array{S}(undef, d)
+default_array(::Type{S}, d) where {S} = Array{S}(undef, d)
+default_array(::Type{Missing}, d) = Array{Missing}(undef, d)
 
 struct StructArrayInitializer{F, G}
     unwrap::F
-    arrayof::G
+    default_array::G
 end
-StructArrayInitializer(unwrap = t->false) = StructArrayInitializer(unwrap, arrayof)
+StructArrayInitializer(unwrap = t->false) = StructArrayInitializer(unwrap, default_array)
 
 const default_initializer = StructArrayInitializer()
 
 function (s::StructArrayInitializer)(S, d)
-    ai = ArrayInitializer(s.unwrap, s.arrayof)
+    ai = ArrayInitializer(s.unwrap, s.default_array)
     buildfromschema(typ -> ai(typ, d), S)
 end
 
 struct ArrayInitializer{F, G}
     unwrap::F
-    arrayof::G
+    default_array::G
 end
-ArrayInitializer(unwrap = t->false) = ArrayInitializer(unwrap, arrayof)
+ArrayInitializer(unwrap = t->false) = ArrayInitializer(unwrap, default_array)
 
-(s::ArrayInitializer)(S, d) = s.unwrap(S) ? buildfromschema(typ -> s(typ, d), S) : s.arrayof(S, d)
+(s::ArrayInitializer)(S, d) = s.unwrap(S) ? buildfromschema(typ -> s(typ, d), S) : s.default_array(S, d)
 
 _reshape(v, itr, ::Base.HasShape) = reshape(v, axes(itr))
 _reshape(v, itr, ::Union{Base.HasLength, Base.SizeUnknown}) = v

src/structarray.jl

@@ -61,6 +61,9 @@ StructArray(s::StructArray) = copy(s)
 Base.convert(::Type{StructArray}, v::AbstractArray) = StructArray(v)
 Base.convert(::Type{StructArray}, v::StructArray) = v
 
+Base.convert(::Type{StructVector}, v::AbstractVector) = StructVector(v)
+Base.convert(::Type{StructVector}, v::StructVector) = v
+
 function Base.similar(::Type{StructArray{T, N, C}}, sz::Dims) where {T, N, C}
     cols = map_params(typ -> similar(typ, sz), C)
     StructArray{T}(cols)

test/runtests.jl

@@ -111,6 +111,13 @@ end
     t3 = StructArray(t)::StructArray
     @test t3 == t
     @test convert(StructArray, t) == t
+
+    v = rand(ComplexF64, 5)
+    t = @inferred StructVector(v)
+    @test t[2] == v[2]
+    @test size(t) == (5,)
+    @test t == convert(StructVector, v)
+    @test t == convert(StructVector, t)
 end
 
 @testset "tuple case" begin
@@ -237,6 +244,17 @@ StructArrays.SkipConstructor(::Type{<:S}) = true
     @test v[1].y isa Float64
 end
 
+@testset "default_array" begin
+    v = StructArrays.default_array(String, (2, 3))
+    @test v isa WeakRefStrings.StringArray{String, 2}
+    v = StructArrays.default_array(Union{String, Missing}, (2, 3))
+    @test v isa WeakRefStrings.StringArray{Union{String, Missing}, 2}
+    v = StructArrays.default_array(Missing, (2,))
+    @test v isa Array{Missing, 1}
+    v = StructArrays.default_array(Int, (2,))
+    @test v isa Array{Int, 1}
+end
+
 const initializer = StructArrays.ArrayInitializer(t -> t <: Union{Tuple, NamedTuple, Pair})
 collect_structarray_rec(t) = collect_structarray(t, initializer = initializer)