take meta serious

Author: SimonDanisch

src/basic_types.jl

@@ -30,6 +30,7 @@ Face index, connecting points to form a simplex
 @fixed_vector SimplexFace AbstractSimplexFace
 const LineFace{T} = SimplexFace{2, T}
 Face(::Type{<: SimplexFace{N}}, ::Type{T}) where {N, T} = SimplexFace{N, T}
+Face(::Type{<: NSimplex{N}}, ::Type{T}) where {N, T} = SimplexFace{N, T}
 
 
 
@@ -71,6 +72,7 @@ const NNgon{N} = Ngon{Dim, T, N, P} where {Dim, T, P}
 function (::Type{<: NNgon{N}})(points::Vararg{P, N}) where {P <: AbstractPoint{Dim, T}, N} where {Dim, T}
     Ngon{Dim, T, N, P}(SVector(points))
 end
+Base.show(io::IO, x::NNgon{N}) where N = print(io, "Ngon{$N}(", join(x, ", "), ")")
 
 # Interfaces
 coordinates(x::Ngon) = x.points
@@ -100,6 +102,7 @@ const Triangle{Dim, T} = TriangleP{Dim, T, Point{Dim, T}}
 const Triangle3d{T} = Triangle{3, T}
 
 Base.show(io::IO, x::TriangleP) = print(io, "Triangle(", join(x, ", "), ")")
+Base.summary(io::IO, x::Type{<: TriangleP}) = print(io, "Triangle")
 
 const Quadrilateral{Dim, T} = Ngon{Dim, T, 4, P} where P <: AbstractPoint{Dim, T}
 
@@ -299,7 +302,11 @@ struct Mesh{
 
     simplices::V
 end
-
+function Base.summary(io::IO, x::Mesh{Dim, T, Element}) where {Dim, T, Element}
+    print(io, "Mesh{$Dim, $T, ")
+    summary(io, Element)
+    print(io, "}")
+end
 Base.size(x::Mesh) = size(x.simplices)
 Base.getindex(x::Mesh, i::Integer) = x.simplices[i]
 

src/metadata.jl

@@ -1,47 +1,122 @@
+#=
+Helper functions that works around the fact, that there is no generic
+Table interface for this functionality. Once this is in e.g. Tables.jl,
+it should be removed from GeometryBasics!
+=#
 
 """
-A point type that holds additional metadata
+Gets the column names of any Array like (Table/AbstractArray)
 """
-struct MetaPoint{N, T, Names, Types} <: AbstractPoint{N, T}
-    point::Point{N, T}
-    meta::NamedTuple{Names, Types}
+function column_names(t)
+    s = Tables.schema(t)
+    if s === nothing
+        return propertynames(first(Tables.rows(t)))
+    else
+        s.names
+    end
 end
 
-function Base.getproperty(x::MetaPoint{Dim, T, Names, Types}, field::Symbol) where {Dim, T, Names, Types}
-    field === :polygon && return getfield(x, :polygon)
-    Base.sym_in(field, Names) && return getfield(getfield(x, :meta), field)
-    error("Field $field not part of Element")
+function hascolumn(t, colname::Symbol)
+    return Base.sym_in(colname, column_names(t))
 end
 
-struct MetaPolygon{
-        Dimension, T <: Real,
-        P <: AbstractPolygon{Dimension, T},
-        Names, Types
-    } <: AbstractPolygon{Dimension, T}
-
-    polygon::P
-    meta::NamedTuple{Names, Types}
+"""
+    getcolumns(t, colnames::Symbol...)
+Gets a column from any Array like (Table/AbstractArray).
+For AbstractVectors, a column will be the field names of the element type.
+"""
+function getcolumns(t, colnames::Symbol...)
+    named_tuple = Tables.columntable(Tables.select(t, colnames...))
+    getfield.((named_tuple,), colnames)
 end
+getcolumn(t, colname::Symbol) = getcolumns(t, colname)[1]
 
-MetaPolygon(polygon::AbstractPolygon; meta...) = MetaPolygon(polygon, values(meta))
-function MetaPolygon(polygon::AbstractVector; meta...)
-    MetaPolygon(Polygon(polygon); meta...)
-end
-function MetaPolygon(exterior::L, interior::AbstractVector{L}; meta...) where L
-    MetaPolygon(Polygon(exterior, interior); meta...)
-end
+"""
+    MetaType(::Type{T})
+Returns the Meta Type corresponding to `T`
+E.g:
+```julia
+MetaType(Point) == PointMeta
+"""
+MetaType(::Type{T}) where T = error("No Meta Type for $T")
 
-function Tables.schema(::AbstractVector{MetaPolygon{Dim, T, P, Names, Types}}) where {Dim, T, P, Names, Types}
-    Tables.Schema((:polygon, Names...), (P, Types...))
-end
-function Base.getproperty(x::MetaPolygon{Dim, T, P, Names, Types}, field::Symbol) where {Dim, T, P, Names, Types}
-    field === :polygon && return getfield(x, :polygon)
-    Base.sym_in(field, Names) && return getfield(getfield(x, :meta), field)
-    error("Field $field not part of Element")
+"""
+    MetaFree(::Type{T})
+Returns the original type containing no metadata for `T`
+E.g:
+```julia
+MetaFree(PointMeta) == Point
+"""
+MetaFree(::Type{T}) where T = error("No meta free Type for $T")
+meta(x::T) where T = error("$T has no meta!")
+metafree(x::T) where T = error("$T has no meta free representation!")
+
+
+macro meta_type(name, mainfield, supertype, params...)
+    MetaName = Symbol("$(name)Meta")
+    field = QuoteNode(mainfield)
+    NoParams = Symbol("$(MetaName)NoParams")
+    expr = quote
+        struct $MetaName{$(params...), Typ <: $supertype{$(params...)}, Names, Types} <: $supertype{$(params...)}
+            main::Typ
+            meta::NamedTuple{Names, Types}
+        end
+
+        const $NoParams{Typ, Names, Types} = $MetaName{$(params...), Typ, Names, Types} where {$(params...)}
+
+        function Base.getproperty(x::$MetaName{$(params...), Typ, Names, Types}, field::Symbol) where {$(params...), Typ, Names, Types}
+            field === $field && return getfield(x, $field)
+            field === :main && return getfield(x, :main)
+            Base.sym_in(field, Names) && return getfield(getfield(x, :meta), field)
+            error("Field $field not part of Element")
+        end
+
+        GeometryBasics.MetaType(T::Type{<: $supertype}) = $MetaName{T}
+        function GeometryBasics.MetaType(
+                ST::Type{<: $supertype{$(params...)}},
+                ::Type{NamedTuple{Names, Types}}) where {$(params...), Names, Types}
+            return $MetaName{$(params...), ST, Names, Types}
+        end
+
+
+        GeometryBasics.MetaFree(::Type{<: $MetaName{Typ}}) where Typ = Typ
+        GeometryBasics.MetaFree(::Type{<: $MetaName}) = $name
+        GeometryBasics.metafree(x::$MetaName) = x.main
+        GeometryBasics.metafree(x::AbstractVector{<: $MetaName}) = getcolumns(x, $field)[1]
+        GeometryBasics.meta(x::$MetaName) = x.meta
+        GeometryBasics.meta(x::AbstractVector{<: $MetaName}) = getcolumns(x, :meta)[1]
+        function (MT::Type{<: $MetaName})(args...; meta...)
+            nt = values(meta)
+            obj = MetaFree(MT)(args...)
+            return MT(obj, nt)
+        end
+
+
+        function StructArrays.staticschema(::Type{$MetaName{$(params...), Typ, Names, Types}}) where {$(params...), Typ, Names, Types}
+            NamedTuple{($field, Names...), Base.tuple_type_cons(Typ, Types)}
+        end
+
+        function StructArrays.createinstance(
+                ::Type{$MetaName{$(params...), Typ, Names, Types}},
+                metafree, args...
+            ) where {$(params...), Typ, Names, Types}
+            $MetaName(metafree, NamedTuple{Names, Types}(args))
+        end
+
+        function GeometryBasics.meta(elements::AbstractVector{T}; meta...) where T <: $supertype
+            nt = values(meta)
+            # get the first element to get the per element named tuple type
+            ElementNT = typeof(map(first, nt))
+            StructArray{MetaType(T, ElementNT)}(($(mainfield) = elements, nt...))
+        end
+
+    end
+    return esc(expr)
 end
 
-Tables.rows(x::MultiPolygon) = x.polygons
-Tables.istable(::Type{<:MultiPolygon}) = true
-Tables.istable(::Type{<:MultiPolygon{<:Tuple}}) = false
-Tables.rowaccess(::Type{<:MultiPolygon}) = true
-# Tables.columnaccess(::Type{<:MultiPolygon}) = true
+@meta_type(Point, point, AbstractPoint, Dim, T)
+Base.getindex(x::PointMeta, idx::Int) = getindex(metafree(x), idx)
+
+
+@meta_type(NgonFace, ngon, AbstractNgonFace, N, T)
+Base.getindex(x::NgonFaceMeta, idx::Int) = getindex(metafree(x), idx)