Implement a Tables interface for features

Project.toml

@@ -6,14 +6,14 @@ desc = "A high level API for GDAL - Geospatial Data Abstraction Library"
 version = "0.3.2"
 
 [deps]
-DataStreams = "9a8bc11e-79be-5b39-94d7-1ccc349a1a85"
+Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
 Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
 GDAL = "add2ef01-049f-52c4-9ee2-e494f65e021a"
 GeoFormatTypes = "68eda718-8dee-11e9-39e7-89f7f65f511f"
 GeoInterface = "cf35fbd7-0cd7-5166-be24-54bfbe79505f"
 
 [compat]
-DataStreams = "0.4.2"
+Tables = "1"
 GDAL = "1.0.2"
 GeoInterface = "0.4, 0.5"
 GeoFormatTypes = "0.3"

src/ArchGDAL.jl

@@ -1,7 +1,7 @@
 module ArchGDAL
 
     import GDAL, GeoInterface, GeoFormatTypes
-    import DataStreams: Data
+    import Tables: Tables
     import GeoInterface: coordinates, geotype
     import Base: convert
 
@@ -30,7 +30,7 @@ module ArchGDAL
     include("context.jl")
     include("base/iterators.jl")
     include("base/display.jl")
-    include("datastreams.jl")
+    include("tables.jl")
     include("geointerface.jl")
     include("convert.jl")
 

src/tables.jl

@@ -0,0 +1,108 @@
+const AG = ArchGDAL
+
+struct GeoTable{T<:Union{IFeatureLayer, FeatureLayer}} 
+    layer::T
+end
+
+function GeoTable(layer)
+    featuredefn = layerdefn(layer)
+    ngeometries = ngeom(featuredefn)
+
+    if(ngeometries == 0 )
+        error("Layer is not a valid ArchGDAL layer")
+    end
+    GeoTable(layer)
+end
+
+struct FeatureRow
+    Row::Array
+    feature_number::Int
+end
+
+function Tables.schema(layer::AG.AbstractFeatureLayer)
+    nfield = AG.nfield(layer)
+    featuredefn = AG.layerdefn(layer)
+    ngeom = ArchGDAL.ngeom(featuredefn)
+
+    fielddefns = (AG.getfielddefn(featuredefn, i) for i in 0:nfield-1)
+    geomdefns = (ArchGDAL.getgeomdefn(featuredefn, i) for i in 0:ngeom-1)
+
+    names_fields = Tuple(AG.getname(fielddefn) for fielddefn in fielddefns)
+    geom_names = Tuple(ArchGDAL.getname(geomdefn) for geomdefn in geomdefns)
+    names = (names_fields..., geom_names...)
+
+    types_fields = Tuple(AG._FIELDTYPE[AG.gettype(fielddefn)] for fielddefn in fielddefns)
+    geom_types = Tuple(ArchGDAL.gettype(geomdefn) for geomdefn in geomdefns)
+    types = (types_fields..., geom_types...)
+
+    Tables.Schema(names, types)
+end
+
+function Base.iterate(gt::GeoTable, st = 0)
+    layer = gt.layer
+    AG.resetreading!(layer)
+    nfeat = AG.nfeature(layer)
+    nfield = AG.nfield(layer)
+    ngeom = AG.ngeom(layer)
+    featuredefn = layerdefn(layer)
+
+    d = Dict{String, Vector}()
+
+    for field_no in 0:nfield-1
+        field = getfielddefn(featuredefn, field_no)
+        name = getname(field)
+        typ = _FIELDTYPE[gettype(field)]
+        d[name] = typ[]
+    end
+    d["geometry"] = IGeometry[]
+
+    st >= nfeat && return nothing
+    AG.nextfeature(layer) do feature
+        for (k, v) in pairs(d)
+            if k == "geometry"
+                val = getgeom(feature, 0)
+            else
+                val = getfield(feature, k)
+            end
+            push!(v, val)
+        end
+    end
+
+    keys_tup = ()
+    for _key in keys(d)
+        keys_tup = (keys_tup..., Symbol(_key))
+    end
+    vals_tup = Tuple(values(d))
+
+    #Using the tables interface
+    Row = Tables.rowtable(NamedTuple{keys_tup}(vals_tup))
+
+    return FeatureRow(Row, st), st + 1
+end
+
+
+Tables.istable(::Type{<:GeoTable}) = true
+Tables.rowaccess(::Type{<:GeoTable}) = true
+Tables.rows(gt::GeoTable) = gt
+
+Base.IteratorSize(::Type{<:GeoTable}) = Base.HasLength()
+Base.size(gt::GeoTable) = nfeature(gt.layer)
+Base.length(gt::GeoTable) = (Base.size(gt::GeoTable)) * (nfield(gt.layer) + ngeom(gt.layer))
+Base.IteratorEltype(::Type{<:GeoTable}) = Base.HasEltype()
+
+Base.propertynames(fr::FeatureRow, gt::GeoTable) = (Tables.schema(gt.layer)).names
+#geometry
+# geometry(fr::FeatureRow) = (fr.Row)
+
+
+function Base.show(io::IO, gt::GeoTable)
+    println(io, "GeoTable with $(ArchGDAL.nfeature(gt.layer)) Features")
+end
+# function Base.show(io::IO, fr::FeatureRow)
+#     println(io, "Feature with properties $(propertynames(fr,gt))")
+# end
+Base.show(io::IO, ::MIME"text/plain", gt::GeoTable) = show(io, gt)
+Base.show(io::IO, ::MIME"text/plain", fr::FeatureRow) = show(io, fr)
+
+
+

test/runtests.jl

@@ -9,7 +9,7 @@ include("remotefiles.jl")
     cd(dirname(@__FILE__)) do
         isdir("tmp") || mkpath("tmp")
         include("test_convert.jl")
-        include("test_datastreams.jl")
+        include("test_tables.jl")
         include("test_gdal_tutorials.jl")
         include("test_geometry.jl")
         include("test_types.jl")

test/test_tables.jl

@@ -0,0 +1,34 @@
+using Test
+import ArchGDAL; const AG = ArchGDAL
+using Tables
+
+@testset "Tables Support" begin
+    # dataset = AG.read("point.geojson")
+    dataset = AG.read(joinpath(@__DIR__, "data/point.geojson"))
+    layer = AG.getlayer(dataset, 0)
+
+    nfeat = AG.nfeature(layer)
+    nfield = AG.nfield(layer)
+    featuredefn = AG.layerdefn(layer)
+    ngeometries = AG.ngeom(featuredefn)
+
+    #testing the main GeoTable function
+    @test sprint(print, AG.GeoTable(layer)) == "GeoTable with 4 Features\n"
+    @test sprint(print, AG.GeoTable(layer)) != "Layer is not a valid ArchGDAL layer\n"      
+
+    # #testing Tables.schema
+    # @test sprint(print, AG.Tables.schema(layer)) == "Tables.Schema:\n :FID        Float64      \n :pointname  String       \n Symbol(\"\")  GDAL.wkbPoint"
+    # #testing Base.iterate
+    # @test sprint(print, AG.Base.iterate(AG.GeoTable(layer))) == "(ArchGDAL.FeatureRow(NamedTuple{(:pointname, :geometry, :FID),Tuple{String,ArchGDAL.IGeometry,Float64}}[(pointname = \"point-a\", geometry = Geometry: POINT (100 0), FID = 2.0)], 0), 1)"
+
+    @test Tables.istable(AG.GeoTable(layer)) == true
+    @test Tables.rowaccess(AG.GeoTable(layer)) == true
+    @test Tables.rows(AG.GeoTable(layer)) == AG.GeoTable(layer)
+
+    @test Base.size(AG.GeoTable(layer)) == 4
+    @test Base.length(AG.GeoTable(layer)) == 12
+
+end
+
+
+