From 32b18378a2eb3cc36790f1f3bcb180459f871406 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Esteban=20Zim=C3=A1nyi?= Date: Sun, 1 Nov 2026 20:14:43 +0100 Subject: [PATCH] Embed each concrete class in its leaf and type geometry arguments as Geo A concrete class embeds its leaf, as MEOS.NET's object layer makes the leaf its base: TGeomPointSeq embeds TGeomPoint and carries its methods, TPoint.AtGeom among them, where it embedded a bare handle and carried none. Witness: with no parent, a concrete class sat at depth 0, so TRGeometrySeqSet, whose catalog C type reads GSERIALIZED, was the shallowest class of that type and wrapped every geometry: 186 geometry arguments of the generated layer, the gs of TGeo.AtGeom among them, read *TRGeometrySeqSet; each now reads *Geo, and none reads *TRGeometrySeqSet. Measured: the 129 root examples pass under TZ=UTC, a temporal point sequence restricted to a polygon through the AtGeom it inherits, as the sequence set MEOS answers; the functions, types and root packages build with no go vet finding, and the parity tests pass. --- example_types_io_test.go | 14 ++ tools/objectgen.py | 15 ++ types/cbuffer.go | 10 +- types/geo.go | 397 +++++++++++++++++++------------------- types/geography.go | 107 +++++----- types/geometry.go | 331 ++++++++++++++++--------------- types/geoset.go | 16 +- types/npoint.go | 4 +- types/nsegment.go | 4 +- types/pcpatch.go | 4 +- types/pose.go | 14 +- types/posechain.go | 4 +- types/raster.go | 2 +- types/stbox.go | 8 +- types/tbigintinst.go | 2 +- types/tbigintseq.go | 2 +- types/tbigintseqset.go | 2 +- types/tboolinst.go | 2 +- types/tboolseq.go | 2 +- types/tboolseqset.go | 2 +- types/tcbuffer.go | 12 +- types/tcbufferinst.go | 2 +- types/tcbufferseq.go | 2 +- types/tcbufferseqset.go | 2 +- types/tfloatinst.go | 2 +- types/tfloatseq.go | 2 +- types/tfloatseqset.go | 2 +- types/tgeo.go | 48 ++--- types/tgeogpointinst.go | 2 +- types/tgeogpointseq.go | 2 +- types/tgeogpointseqset.go | 2 +- types/tgeographyinst.go | 2 +- types/tgeographyseq.go | 2 +- types/tgeographyseqset.go | 2 +- types/tgeometryinst.go | 2 +- types/tgeometryseq.go | 2 +- types/tgeometryseqset.go | 2 +- types/tgeompointinst.go | 2 +- types/tgeompointseq.go | 2 +- types/tgeompointseqset.go | 2 +- types/th3indexinst.go | 2 +- types/th3indexseq.go | 2 +- types/th3indexseqset.go | 2 +- types/tintinst.go | 2 +- types/tintseq.go | 2 +- types/tintseqset.go | 2 +- types/tjsonbinst.go | 2 +- types/tjsonbseq.go | 2 +- types/tjsonbseqset.go | 2 +- types/tnpoint.go | 12 +- types/tnpointinst.go | 2 +- types/tnpointseq.go | 2 +- types/tnpointseqset.go | 2 +- types/tpcpatchinst.go | 2 +- types/tpcpatchseq.go | 2 +- types/tpcpatchseqset.go | 2 +- types/tpcpointinst.go | 2 +- types/tpcpointseq.go | 2 +- types/tpcpointseqset.go | 2 +- types/tpoint.go | 22 +-- types/tpose.go | 10 +- types/tposechaininst.go | 2 +- types/tposechainseq.go | 2 +- types/tposechainseqset.go | 2 +- types/tposeinst.go | 2 +- types/tposeseq.go | 2 +- types/tposeseqset.go | 2 +- types/tquadbininst.go | 2 +- types/tquadbinseq.go | 2 +- types/tquadbinseqset.go | 2 +- types/trgeometry.go | 40 ++-- types/trgeometryinst.go | 4 +- types/trgeometryseq.go | 4 +- types/trgeometryseqset.go | 8 +- types/ts2cellinst.go | 2 +- types/ts2cellseq.go | 2 +- types/ts2cellseqset.go | 2 +- types/ttextinst.go | 2 +- types/ttextseq.go | 2 +- types/ttextseqset.go | 2 +- 80 files changed, 638 insertions(+), 566 deletions(-) diff --git a/example_types_io_test.go b/example_types_io_test.go index 5cfcd4c..2023998 100644 --- a/example_types_io_test.go +++ b/example_types_io_test.go @@ -37,6 +37,20 @@ func ExampleTGeomPointFromHexEWKB() { // POINT(1 1)@2024-12-06 00:00:00+00 } +func Example_sequenceAtGeometry() { + // A sequence carries the methods of its leaf, and a geometry argument is + // a *Geo: TGeomPointSeq reaches TPoint.AtGeom through TGeomPoint, whose + // restriction MEOS answers as a sequence set. It reads the value as + // #ExampleTGeomPointFromText does. + temp, _ := types.TGeomPointFromText("[Point(0 0)@2024-12-06, Point(2 0)@2024-12-08]") + seq := types.TGeomPointSeqFromPointer(temp.Pointer()) + box, _ := types.GeometryFromText("Polygon((0 -1,1 -1,1 1,0 1,0 -1))", 0) + at, err := seq.AtGeom(&box.Geo) + fmt.Println(types.TGeomPointFromPointer(at.Pointer()), err) + // Output: + // {[POINT(0 0)@2024-12-06 00:00:00+00, POINT(1 0)@2024-12-07 00:00:00+00]} +} + func Example_cbufferString() { cbuffer, _ := types.CbufferFromText("Cbuffer(Point(1 1),0.5)") fmt.Println(cbuffer) diff --git a/tools/objectgen.py b/tools/objectgen.py index 4e74fb6..142a60f 100644 --- a/tools/objectgen.py +++ b/tools/objectgen.py @@ -101,6 +101,11 @@ def zero(go_type: str) -> str: return "0" +# The suffix a concrete class takes for each template subtype, as MEOS.NET's +# tools/objectgen.py names them. +SUBTYPE_SUFFIX = {"TInstant": "Inst", "TSequence": "Seq", "TSequenceSet": "SeqSet"} + + class Model: """The class hierarchy the catalog defines, indexed for emission.""" @@ -129,6 +134,16 @@ def _build(self) -> None: if cls: self.parent[cls] = "Temporal" + # A concrete class is `` and embeds its leaf, so it + # carries the leaf's family surface (TGeomPointSeq the methods of + # TGeomPoint), as #_build of MEOS.NET's tools/objectgen.py makes the + # leaf its base. + for leaf in [n for n, v in self.om["lattice"].items() + if isinstance(v, dict) and v.get("kind") == "leaf"]: + for suffix in SUBTYPE_SUFFIX.values(): + if leaf + suffix in self.om["classes"]: + self.parent[leaf + suffix] = leaf + for family in [k for k in self.om["companions"] if not k.startswith("_")]: for name, node in self.om["companions"][family]["nodes"].items(): if name.startswith("_"): diff --git a/types/cbuffer.go b/types/cbuffer.go index cd85b1f..c980d54 100644 --- a/types/cbuffer.go +++ b/types/cbuffer.go @@ -131,7 +131,7 @@ func (x *Cbuffer) Copy() (*Cbuffer, error) { } // CbufferMake is MEOS cbuffer_make. -func CbufferMake(point *TRGeometrySeqSet, radius float64) (*Cbuffer, error) { +func CbufferMake(point *Geo, radius float64) (*Cbuffer, error) { _r0, _err := functions.CbufferMake(functions.GeomFromPointer(point.Pointer()), radius) if _err != nil { return nil, _err @@ -140,12 +140,12 @@ func CbufferMake(point *TRGeometrySeqSet, radius float64) (*Cbuffer, error) { } // ToGeom is MEOS cbuffer_to_geom. -func (x *Cbuffer) ToGeom() (*TRGeometrySeqSet, error) { +func (x *Cbuffer) ToGeom() (*Geo, error) { _r0, _err := functions.CbufferToGeom(functions.CbufferFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // ToStbox is MEOS cbuffer_to_stbox. @@ -185,12 +185,12 @@ func (x *Cbuffer) MemSize() (int, error) { } // Point is MEOS cbuffer_point. -func (x *Cbuffer) Point() (*TRGeometrySeqSet, error) { +func (x *Cbuffer) Point() (*Geo, error) { _r0, _err := functions.CbufferPoint(functions.CbufferFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // Radius is MEOS cbuffer_radius. diff --git a/types/geo.go b/types/geo.go index 9fc2426..d7e7773 100644 --- a/types/geo.go +++ b/types/geo.go @@ -23,46 +23,46 @@ func GeoFromPointer(p unsafe.Pointer) *Geo { return v } -// GeoAsEWKB is MEOS geo_as_ewkb. -func GeoAsEWKB(gs *TRGeometrySeqSet, endian *string) ([]byte, error) { +// AsEWKB is MEOS geo_as_ewkb. +func (x *Geo) AsEWKB(endian *string) ([]byte, error) { var _size uint64 - _r0, _err := functions.GeoAsEWKB(functions.GeomFromPointer(gs.Pointer()), endian, unsafe.Pointer(&_size)) + _r0, _err := functions.GeoAsEWKB(functions.GeomFromPointer(x.Pointer()), endian, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } return functions.TakeBytes(_r0, _size), nil } -// GeoAsEWKT is MEOS geo_as_ewkt. -func GeoAsEWKT(gs *TRGeometrySeqSet, precision int) (string, error) { - _r0, _err := functions.GeoAsEWKT(functions.GeomFromPointer(gs.Pointer()), precision) +// AsEWKT is MEOS geo_as_ewkt. +func (x *Geo) AsEWKT(precision int) (string, error) { + _r0, _err := functions.GeoAsEWKT(functions.GeomFromPointer(x.Pointer()), precision) if _err != nil { return "", _err } return _r0, nil } -// GeoAsGeoJSON is MEOS geo_as_geojson. -func GeoAsGeoJSON(gs *TRGeometrySeqSet, option int, precision int, srs *string) (string, error) { - _r0, _err := functions.GeoAsGeojson(functions.GeomFromPointer(gs.Pointer()), option, precision, srs) +// AsGeoJSON is MEOS geo_as_geojson. +func (x *Geo) AsGeoJSON(option int, precision int, srs *string) (string, error) { + _r0, _err := functions.GeoAsGeojson(functions.GeomFromPointer(x.Pointer()), option, precision, srs) if _err != nil { return "", _err } return _r0, nil } -// GeoAsHexEWKB is MEOS geo_as_hexewkb. -func GeoAsHexEWKB(gs *TRGeometrySeqSet, endian *string) (string, error) { - _r0, _err := functions.GeoAsHexewkb(functions.GeomFromPointer(gs.Pointer()), endian) +// AsHexEWKB is MEOS geo_as_hexewkb. +func (x *Geo) AsHexEWKB(endian *string) (string, error) { + _r0, _err := functions.GeoAsHexewkb(functions.GeomFromPointer(x.Pointer()), endian) if _err != nil { return "", _err } return _r0, nil } -// GeoAsText is MEOS geo_as_text. -func GeoAsText(gs *TRGeometrySeqSet, precision int) (string, error) { - _r0, _err := functions.GeoAsText(functions.GeomFromPointer(gs.Pointer()), precision) +// AsText is MEOS geo_as_text. +func (x *Geo) AsText(precision int) (string, error) { + _r0, _err := functions.GeoAsText(functions.GeomFromPointer(x.Pointer()), precision) if _err != nil { return "", _err } @@ -70,7 +70,7 @@ func GeoAsText(gs *TRGeometrySeqSet, precision int) (string, error) { } // GeoFromEWKB is MEOS geo_from_ewkb. -func GeoFromEWKB(wkb []byte, srid int32) (*TRGeometrySeqSet, error) { +func GeoFromEWKB(wkb []byte, srid int32) (*Geo, error) { var _p_wkb unsafe.Pointer if len(wkb) > 0 { _p_wkb = unsafe.Pointer(&wkb[0]) @@ -79,102 +79,102 @@ func GeoFromEWKB(wkb []byte, srid int32) (*TRGeometrySeqSet, error) { if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // GeoFromGeoJSON is MEOS geo_from_geojson. -func GeoFromGeoJSON(geojson string) (*TRGeometrySeqSet, error) { +func GeoFromGeoJSON(geojson string) (*Geo, error) { _r0, _err := functions.GeoFromGeojson(geojson) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // GeoFromText is MEOS geo_from_text. -func GeoFromText(wkt string, srid int32) (*TRGeometrySeqSet, error) { +func GeoFromText(wkt string, srid int32) (*Geo, error) { _r0, _err := functions.GeoFromText(wkt, srid) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoOut is MEOS geo_out. -func GeoOut(gs *TRGeometrySeqSet) (string, error) { - _r0, _err := functions.GeoOut(functions.GeomFromPointer(gs.Pointer())) +// Out is MEOS geo_out. +func (x *Geo) Out() (string, error) { + _r0, _err := functions.GeoOut(functions.GeomFromPointer(x.Pointer())) if _err != nil { return "", _err } return _r0, nil } -// GeoCopy is MEOS geo_copy. -func GeoCopy(gs *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoCopy(functions.GeomFromPointer(gs.Pointer())) +// Copy is MEOS geo_copy. +func (x *Geo) Copy() (*Geo, error) { + _r0, _err := functions.GeoCopy(functions.GeomFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoIsEmpty is MEOS geo_is_empty. -func GeoIsEmpty(gs *TRGeometrySeqSet) (bool, error) { - _r0, _err := functions.GeoIsEmpty(functions.GeomFromPointer(gs.Pointer())) +// IsEmpty is MEOS geo_is_empty. +func (x *Geo) IsEmpty() (bool, error) { + _r0, _err := functions.GeoIsEmpty(functions.GeomFromPointer(x.Pointer())) if _err != nil { return false, _err } return _r0, nil } -// GeoIsUnitary is MEOS geo_is_unitary. -func GeoIsUnitary(gs *TRGeometrySeqSet) (bool, error) { - _r0, _err := functions.GeoIsUnitary(functions.GeomFromPointer(gs.Pointer())) +// IsUnitary is MEOS geo_is_unitary. +func (x *Geo) IsUnitary() (bool, error) { + _r0, _err := functions.GeoIsUnitary(functions.GeomFromPointer(x.Pointer())) if _err != nil { return false, _err } return _r0, nil } -// GeoMemSize is MEOS geo_mem_size. -func GeoMemSize(gs *TRGeometrySeqSet) (int, error) { - _r0, _err := functions.GeoMemSize(functions.GeomFromPointer(gs.Pointer())) +// MemSize is MEOS geo_mem_size. +func (x *Geo) MemSize() (int, error) { + _r0, _err := functions.GeoMemSize(functions.GeomFromPointer(x.Pointer())) if _err != nil { return 0, _err } return _r0, nil } -// GeoArea is MEOS geo_area. -func GeoArea(gs *TRGeometrySeqSet, spheroid bool) (float64, error) { - _r0, _err := functions.GeoArea(functions.GeomFromPointer(gs.Pointer()), spheroid) +// Area is MEOS geo_area. +func (x *Geo) Area(spheroid bool) (float64, error) { + _r0, _err := functions.GeoArea(functions.GeomFromPointer(x.Pointer()), spheroid) if _err != nil { return 0, _err } return _r0, nil } -// GeoCentroid is MEOS geo_centroid. -func GeoCentroid(gs *TRGeometrySeqSet, spheroid bool) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoCentroid(functions.GeomFromPointer(gs.Pointer()), spheroid) +// Centroid is MEOS geo_centroid. +func (x *Geo) Centroid(spheroid bool) (*Geo, error) { + _r0, _err := functions.GeoCentroid(functions.GeomFromPointer(x.Pointer()), spheroid) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoLength is MEOS geo_length. -func GeoLength(gs *TRGeometrySeqSet, spheroid bool) (float64, error) { - _r0, _err := functions.GeoLength(functions.GeomFromPointer(gs.Pointer()), spheroid) +// Length is MEOS geo_length. +func (x *Geo) Length(spheroid bool) (float64, error) { + _r0, _err := functions.GeoLength(functions.GeomFromPointer(x.Pointer()), spheroid) if _err != nil { return 0, _err } return _r0, nil } -// GeoPerimeter is MEOS geo_perimeter. -func GeoPerimeter(gs *TRGeometrySeqSet, spheroid bool) (float64, error) { - _r0, _err := functions.GeoPerimeter(functions.GeomFromPointer(gs.Pointer()), spheroid) +// Perimeter is MEOS geo_perimeter. +func (x *Geo) Perimeter(spheroid bool) (float64, error) { + _r0, _err := functions.GeoPerimeter(functions.GeomFromPointer(x.Pointer()), spheroid) if _err != nil { return 0, _err } @@ -190,324 +190,324 @@ func GeoTypename(type_ int) (string, error) { return _r0, nil } -// GeoAffine is MEOS geo_affine. -func GeoAffine(gs *TRGeometrySeqSet, a float64, b float64, c float64, d float64, e float64, f float64, g float64, h float64, i float64, xoff float64, yoff float64, zoff float64) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoAffine(functions.GeomFromPointer(gs.Pointer()), a, b, c, d, e, f, g, h, i, xoff, yoff, zoff) +// Affine is MEOS geo_affine. +func (x *Geo) Affine(a float64, b float64, c float64, d float64, e float64, f float64, g float64, h float64, i float64, xoff float64, yoff float64, zoff float64) (*Geo, error) { + _r0, _err := functions.GeoAffine(functions.GeomFromPointer(x.Pointer()), a, b, c, d, e, f, g, h, i, xoff, yoff, zoff) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoReverse is MEOS geo_reverse. -func GeoReverse(gs *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoReverse(functions.GeomFromPointer(gs.Pointer())) +// Reverse is MEOS geo_reverse. +func (x *Geo) Reverse() (*Geo, error) { + _r0, _err := functions.GeoReverse(functions.GeomFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoRotate is MEOS geo_rotate. -func GeoRotate(gs *TRGeometrySeqSet, angle float64, x0 float64, y0 float64) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoRotate(functions.GeomFromPointer(gs.Pointer()), angle, x0, y0) +// Rotate is MEOS geo_rotate. +func (x *Geo) Rotate(angle float64, x0 float64, y0 float64) (*Geo, error) { + _r0, _err := functions.GeoRotate(functions.GeomFromPointer(x.Pointer()), angle, x0, y0) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoRotateGeo is MEOS geo_rotate_geo. -func GeoRotateGeo(gs *TRGeometrySeqSet, angle float64, origin *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoRotateGeo(functions.GeomFromPointer(gs.Pointer()), angle, functions.GeomFromPointer(origin.Pointer())) +// RotateGeo is MEOS geo_rotate_geo. +func (x *Geo) RotateGeo(angle float64, origin *Geo) (*Geo, error) { + _r0, _err := functions.GeoRotateGeo(functions.GeomFromPointer(x.Pointer()), angle, functions.GeomFromPointer(origin.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoRotateX is MEOS geo_rotate_x. -func GeoRotateX(gs *TRGeometrySeqSet, angle float64) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoRotateX(functions.GeomFromPointer(gs.Pointer()), angle) +// RotateX is MEOS geo_rotate_x. +func (x *Geo) RotateX(angle float64) (*Geo, error) { + _r0, _err := functions.GeoRotateX(functions.GeomFromPointer(x.Pointer()), angle) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoRotateY is MEOS geo_rotate_y. -func GeoRotateY(gs *TRGeometrySeqSet, angle float64) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoRotateY(functions.GeomFromPointer(gs.Pointer()), angle) +// RotateY is MEOS geo_rotate_y. +func (x *Geo) RotateY(angle float64) (*Geo, error) { + _r0, _err := functions.GeoRotateY(functions.GeomFromPointer(x.Pointer()), angle) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoRotateZ is MEOS geo_rotate_z. -func GeoRotateZ(gs *TRGeometrySeqSet, angle float64) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoRotateZ(functions.GeomFromPointer(gs.Pointer()), angle) +// RotateZ is MEOS geo_rotate_z. +func (x *Geo) RotateZ(angle float64) (*Geo, error) { + _r0, _err := functions.GeoRotateZ(functions.GeomFromPointer(x.Pointer()), angle) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoRound is MEOS geo_round. -func GeoRound(gs *TRGeometrySeqSet, maxdd int) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoRound(functions.GeomFromPointer(gs.Pointer()), maxdd) +// Round is MEOS geo_round. +func (x *Geo) Round(maxdd int) (*Geo, error) { + _r0, _err := functions.GeoRound(functions.GeomFromPointer(x.Pointer()), maxdd) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoScale is MEOS geo_scale. -func GeoScale(gs *TRGeometrySeqSet, xfactor float64, yfactor float64, zfactor float64) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoScale(functions.GeomFromPointer(gs.Pointer()), xfactor, yfactor, zfactor) +// Scale is MEOS geo_scale. +func (x *Geo) Scale(xfactor float64, yfactor float64, zfactor float64) (*Geo, error) { + _r0, _err := functions.GeoScale(functions.GeomFromPointer(x.Pointer()), xfactor, yfactor, zfactor) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoScaleGeo is MEOS geo_scale_geo. -func GeoScaleGeo(gs *TRGeometrySeqSet, scale *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoScaleGeo(functions.GeomFromPointer(gs.Pointer()), functions.GeomFromPointer(scale.Pointer())) +// ScaleGeo is MEOS geo_scale_geo. +func (x *Geo) ScaleGeo(scale *Geo) (*Geo, error) { + _r0, _err := functions.GeoScaleGeo(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(scale.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoScaleGeoOrigin is MEOS geo_scale_geo_origin. -func GeoScaleGeoOrigin(gs *TRGeometrySeqSet, scale *TRGeometrySeqSet, sorigin *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoScaleGeoOrigin(functions.GeomFromPointer(gs.Pointer()), functions.GeomFromPointer(scale.Pointer()), functions.GeomFromPointer(sorigin.Pointer())) +// ScaleGeoOrigin is MEOS geo_scale_geo_origin. +func (x *Geo) ScaleGeoOrigin(scale *Geo, sorigin *Geo) (*Geo, error) { + _r0, _err := functions.GeoScaleGeoOrigin(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(scale.Pointer()), functions.GeomFromPointer(sorigin.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoSegmentize is MEOS geo_segmentize. -func GeoSegmentize(gs *TRGeometrySeqSet, max_seg_length float64) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoSegmentize(functions.GeomFromPointer(gs.Pointer()), max_seg_length) +// Segmentize is MEOS geo_segmentize. +func (x *Geo) Segmentize(max_seg_length float64) (*Geo, error) { + _r0, _err := functions.GeoSegmentize(functions.GeomFromPointer(x.Pointer()), max_seg_length) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoTranslate is MEOS geo_translate. -func GeoTranslate(gs *TRGeometrySeqSet, deltax float64, deltay float64, deltaz float64) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoTranslate(functions.GeomFromPointer(gs.Pointer()), deltax, deltay, deltaz) +// Translate is MEOS geo_translate. +func (x *Geo) Translate(deltax float64, deltay float64, deltaz float64) (*Geo, error) { + _r0, _err := functions.GeoTranslate(functions.GeomFromPointer(x.Pointer()), deltax, deltay, deltaz) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoTransscale is MEOS geo_transscale. -func GeoTransscale(gs *TRGeometrySeqSet, deltax float64, deltay float64, xfactor float64, yfactor float64) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoTransscale(functions.GeomFromPointer(gs.Pointer()), deltax, deltay, xfactor, yfactor) +// Transscale is MEOS geo_transscale. +func (x *Geo) Transscale(deltax float64, deltay float64, xfactor float64, yfactor float64) (*Geo, error) { + _r0, _err := functions.GeoTransscale(functions.GeomFromPointer(x.Pointer()), deltax, deltay, xfactor, yfactor) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoSetSRID is MEOS geo_set_srid. -func GeoSetSRID(gs *TRGeometrySeqSet, srid int32) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoSetSRID(functions.GeomFromPointer(gs.Pointer()), srid) +// SetSRID is MEOS geo_set_srid. +func (x *Geo) SetSRID(srid int32) (*Geo, error) { + _r0, _err := functions.GeoSetSRID(functions.GeomFromPointer(x.Pointer()), srid) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoSRID is MEOS geo_srid. -func GeoSRID(gs *TRGeometrySeqSet) (int32, error) { - _r0, _err := functions.GeoSRID(functions.GeomFromPointer(gs.Pointer())) +// SRID is MEOS geo_srid. +func (x *Geo) SRID() (int32, error) { + _r0, _err := functions.GeoSRID(functions.GeomFromPointer(x.Pointer())) if _err != nil { return 0, _err } return _r0, nil } -// GeoTransform is MEOS geo_transform. -func GeoTransform(geom *TRGeometrySeqSet, srid_to int32) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoTransform(functions.GeomFromPointer(geom.Pointer()), srid_to) +// Transform is MEOS geo_transform. +func (x *Geo) Transform(srid_to int32) (*Geo, error) { + _r0, _err := functions.GeoTransform(functions.GeomFromPointer(x.Pointer()), srid_to) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoTransformPipeline is MEOS geo_transform_pipeline. -func GeoTransformPipeline(gs *TRGeometrySeqSet, pipelinestr string, srid int32, is_forward bool) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoTransformPipeline(functions.GeomFromPointer(gs.Pointer()), pipelinestr, srid, is_forward) +// TransformPipeline is MEOS geo_transform_pipeline. +func (x *Geo) TransformPipeline(pipelinestr string, srid int32, is_forward bool) (*Geo, error) { + _r0, _err := functions.GeoTransformPipeline(functions.GeomFromPointer(x.Pointer()), pipelinestr, srid, is_forward) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // GeoCollectGarray is MEOS geo_collect_garray. -func GeoCollectGarray(gsarr unsafe.Pointer, count int) (*TRGeometrySeqSet, error) { +func GeoCollectGarray(gsarr unsafe.Pointer, count int) (*Geo, error) { _r0, _err := functions.GeoCollectGarray(gsarr, count) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // GeoMakelineGarray is MEOS geo_makeline_garray. -func GeoMakelineGarray(gsarr unsafe.Pointer, count int) (*TRGeometrySeqSet, error) { +func GeoMakelineGarray(gsarr unsafe.Pointer, count int) (*Geo, error) { _r0, _err := functions.GeoMakelineGarray(gsarr, count) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoNumPoints is MEOS geo_num_points. -func GeoNumPoints(gs *TRGeometrySeqSet) (int, error) { - _r0, _err := functions.GeoNumPoints(functions.GeomFromPointer(gs.Pointer())) +// NumPoints is MEOS geo_num_points. +func (x *Geo) NumPoints() (int, error) { + _r0, _err := functions.GeoNumPoints(functions.GeomFromPointer(x.Pointer())) if _err != nil { return 0, _err } return _r0, nil } -// GeoNumGeos is MEOS geo_num_geos. -func GeoNumGeos(gs *TRGeometrySeqSet) (int, error) { - _r0, _err := functions.GeoNumGeos(functions.GeomFromPointer(gs.Pointer())) +// NumGeos is MEOS geo_num_geos. +func (x *Geo) NumGeos() (int, error) { + _r0, _err := functions.GeoNumGeos(functions.GeomFromPointer(x.Pointer())) if _err != nil { return 0, _err } return _r0, nil } -// GeoGeoN is MEOS geo_geo_n. -func GeoGeoN(geom *TRGeometrySeqSet, n int) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoGeoN(functions.GeomFromPointer(geom.Pointer()), n) +// GeoN is MEOS geo_geo_n. +func (x *Geo) GeoN(n int) (*Geo, error) { + _r0, _err := functions.GeoGeoN(functions.GeomFromPointer(x.Pointer()), n) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoPointarr is MEOS geo_pointarr. -func GeoPointarr(gs *TRGeometrySeqSet, count unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.GeoPointarr(functions.GeomFromPointer(gs.Pointer()), count) +// Pointarr is MEOS geo_pointarr. +func (x *Geo) Pointarr(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.GeoPointarr(functions.GeomFromPointer(x.Pointer()), count) if _err != nil { return nil, _err } return _r0, nil } -// GeoPoints is MEOS geo_points. -func GeoPoints(gs *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoPoints(functions.GeomFromPointer(gs.Pointer())) +// Points is MEOS geo_points. +func (x *Geo) Points() (*Geo, error) { + _r0, _err := functions.GeoPoints(functions.GeomFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoStboxes is MEOS geo_stboxes. -func GeoStboxes(gs *TRGeometrySeqSet, count unsafe.Pointer) (*STBox, error) { - _r0, _err := functions.GeoStboxes(functions.GeomFromPointer(gs.Pointer()), count) +// Stboxes is MEOS geo_stboxes. +func (x *Geo) Stboxes(count unsafe.Pointer) (*STBox, error) { + _r0, _err := functions.GeoStboxes(functions.GeomFromPointer(x.Pointer()), count) if _err != nil { return nil, _err } return STBoxFromPointer(_r0.Pointer()), nil } -// GeoSplitEachNStboxes is MEOS geo_split_each_n_stboxes. -func GeoSplitEachNStboxes(gs *TRGeometrySeqSet, elem_count int, count unsafe.Pointer) (*STBox, error) { - _r0, _err := functions.GeoSplitEachNStboxes(functions.GeomFromPointer(gs.Pointer()), elem_count, count) +// SplitEachNStboxes is MEOS geo_split_each_n_stboxes. +func (x *Geo) SplitEachNStboxes(elem_count int, count unsafe.Pointer) (*STBox, error) { + _r0, _err := functions.GeoSplitEachNStboxes(functions.GeomFromPointer(x.Pointer()), elem_count, count) if _err != nil { return nil, _err } return STBoxFromPointer(_r0.Pointer()), nil } -// GeoSplitNStboxes is MEOS geo_split_n_stboxes. -func GeoSplitNStboxes(gs *TRGeometrySeqSet, box_count int, count unsafe.Pointer) (*STBox, error) { - _r0, _err := functions.GeoSplitNStboxes(functions.GeomFromPointer(gs.Pointer()), box_count, count) +// SplitNStboxes is MEOS geo_split_n_stboxes. +func (x *Geo) SplitNStboxes(box_count int, count unsafe.Pointer) (*STBox, error) { + _r0, _err := functions.GeoSplitNStboxes(functions.GeomFromPointer(x.Pointer()), box_count, count) if _err != nil { return nil, _err } return STBoxFromPointer(_r0.Pointer()), nil } -// GeoDistance is MEOS geo_distance. -func GeoDistance(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet, spheroid bool) (float64, error) { - _r0, _err := functions.GeoDistance(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer()), spheroid) +// Distance is MEOS geo_distance. +func (x *Geo) Distance(gs2 *Geo, spheroid bool) (float64, error) { + _r0, _err := functions.GeoDistance(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer()), spheroid) if _err != nil { return 0, _err } return _r0, nil } -// GeoShortestline is MEOS geo_shortestline. -func GeoShortestline(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet, spheroid bool) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoShortestline(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer()), spheroid) +// Shortestline is MEOS geo_shortestline. +func (x *Geo) Shortestline(gs2 *Geo, spheroid bool) (*Geo, error) { + _r0, _err := functions.GeoShortestline(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer()), spheroid) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeoEquals is MEOS geo_equals. -func GeoEquals(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (int, error) { - _r0, _err := functions.GeoEquals(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Equals is MEOS geo_equals. +func (x *Geo) Equals(gs2 *Geo) (int, error) { + _r0, _err := functions.GeoEquals(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return 0, _err } return _r0, nil } -// GeoSame is MEOS geo_same. -func GeoSame(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (bool, error) { - _r0, _err := functions.GeoSame(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Same is MEOS geo_same. +func (x *Geo) Same(gs2 *Geo) (bool, error) { + _r0, _err := functions.GeoSame(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return false, _err } return _r0, nil } -// GeoToSet is MEOS geo_to_set. -func GeoToSet(gs *TRGeometrySeqSet) (*Set, error) { - _r0, _err := functions.GeoToSet(functions.GeomFromPointer(gs.Pointer())) +// ToSet is MEOS geo_to_set. +func (x *Geo) ToSet() (*Set, error) { + _r0, _err := functions.GeoToSet(functions.GeomFromPointer(x.Pointer())) if _err != nil { return nil, _err } return SetFromPointer(_r0.Pointer()), nil } -// GeoTimestamptzToStbox is MEOS geo_timestamptz_to_stbox. -func GeoTimestamptzToStbox(gs *TRGeometrySeqSet, t int64) (*STBox, error) { - _r0, _err := functions.GeoTimestamptzToSTBOX(functions.GeomFromPointer(gs.Pointer()), t) +// TimestamptzToStbox is MEOS geo_timestamptz_to_stbox. +func (x *Geo) TimestamptzToStbox(t int64) (*STBox, error) { + _r0, _err := functions.GeoTimestamptzToSTBOX(functions.GeomFromPointer(x.Pointer()), t) if _err != nil { return nil, _err } return STBoxFromPointer(_r0.Pointer()), nil } -// GeoTstzspanToStbox is MEOS geo_tstzspan_to_stbox. -func GeoTstzspanToStbox(gs *TRGeometrySeqSet, s *Span) (*STBox, error) { - _r0, _err := functions.GeoTstzspanToSTBOX(functions.GeomFromPointer(gs.Pointer()), functions.SpanFromPointer(s.Pointer())) +// TstzspanToStbox is MEOS geo_tstzspan_to_stbox. +func (x *Geo) TstzspanToStbox(s *Span) (*STBox, error) { + _r0, _err := functions.GeoTstzspanToSTBOX(functions.GeomFromPointer(x.Pointer()), functions.SpanFromPointer(s.Pointer())) if _err != nil { return nil, _err } return STBoxFromPointer(_r0.Pointer()), nil } -// GeoToStbox is MEOS geo_to_stbox. -func GeoToStbox(gs *TRGeometrySeqSet) (*STBox, error) { - _r0, _err := functions.GeoToSTBOX(functions.GeomFromPointer(gs.Pointer())) +// ToStbox is MEOS geo_to_stbox. +func (x *Geo) ToStbox() (*STBox, error) { + _r0, _err := functions.GeoToSTBOX(functions.GeomFromPointer(x.Pointer())) if _err != nil { return nil, _err } @@ -550,56 +550,65 @@ func GeoClusterWithin(geoms unsafe.Pointer, ngeoms uint32, tolerance float64, co return _r0, nil } -// GeoToH3indexCell is MEOS geo_to_h3index_cell. -func GeoToH3indexCell(point *TRGeometrySeqSet, resolution int32) (uint64, error) { - _r0, _err := functions.GeoToH3indexCell(functions.GeomFromPointer(point.Pointer()), resolution) +// ToH3indexCell is MEOS geo_to_h3index_cell. +func (x *Geo) ToH3indexCell(resolution int32) (uint64, error) { + _r0, _err := functions.GeoToH3indexCell(functions.GeomFromPointer(x.Pointer()), resolution) if _err != nil { return 0, _err } return _r0, nil } -// GeoToH3indexSet is MEOS geo_to_h3index_set. -func GeoToH3indexSet(gs *TRGeometrySeqSet, resolution int32) (*Set, error) { - _r0, _err := functions.GeoToH3indexSet(functions.GeomFromPointer(gs.Pointer()), resolution) +// ToH3indexSet is MEOS geo_to_h3index_set. +func (x *Geo) ToH3indexSet(resolution int32) (*Set, error) { + _r0, _err := functions.GeoToH3indexSet(functions.GeomFromPointer(x.Pointer()), resolution) if _err != nil { return nil, _err } return SetFromPointer(_r0.Pointer()), nil } -// GeoToQuadbinCell is MEOS geo_to_quadbin_cell. -func GeoToQuadbinCell(point *TRGeometrySeqSet, resolution int32) (uint64, error) { - _r0, _err := functions.GeoToQuadbinCell(functions.GeomFromPointer(point.Pointer()), resolution) +// ToQuadbinCell is MEOS geo_to_quadbin_cell. +func (x *Geo) ToQuadbinCell(resolution int32) (uint64, error) { + _r0, _err := functions.GeoToQuadbinCell(functions.GeomFromPointer(x.Pointer()), resolution) if _err != nil { return 0, _err } return _r0, nil } -// GeoToQuadbinSet is MEOS geo_to_quadbin_set. -func GeoToQuadbinSet(gs *TRGeometrySeqSet, resolution int32) (*Set, error) { - _r0, _err := functions.GeoToQuadbinSet(functions.GeomFromPointer(gs.Pointer()), resolution) +// ToQuadbinSet is MEOS geo_to_quadbin_set. +func (x *Geo) ToQuadbinSet(resolution int32) (*Set, error) { + _r0, _err := functions.GeoToQuadbinSet(functions.GeomFromPointer(x.Pointer()), resolution) if _err != nil { return nil, _err } return SetFromPointer(_r0.Pointer()), nil } -// GeoToS2cellCell is MEOS geo_to_s2cell_cell. -func GeoToS2cellCell(point *TRGeometrySeqSet, level int32) (uint64, error) { - _r0, _err := functions.GeoToS2cellCell(functions.GeomFromPointer(point.Pointer()), level) +// ToS2cellCell is MEOS geo_to_s2cell_cell. +func (x *Geo) ToS2cellCell(level int32) (uint64, error) { + _r0, _err := functions.GeoToS2cellCell(functions.GeomFromPointer(x.Pointer()), level) if _err != nil { return 0, _err } return _r0, nil } -// GeoToS2cellSet is MEOS geo_to_s2cell_set. -func GeoToS2cellSet(gs *TRGeometrySeqSet, level int32) (*Set, error) { - _r0, _err := functions.GeoToS2cellSet(functions.GeomFromPointer(gs.Pointer()), level) +// ToS2cellSet is MEOS geo_to_s2cell_set. +func (x *Geo) ToS2cellSet(level int32) (*Set, error) { + _r0, _err := functions.GeoToS2cellSet(functions.GeomFromPointer(x.Pointer()), level) if _err != nil { return nil, _err } return SetFromPointer(_r0.Pointer()), nil } + +// String is the text MEOS writes this value as, MEOS geo_as_text. +func (x *Geo) String() string { + s, err := x.AsText(15) + if err != nil { + return "%!s(MEOS error: " + err.Error() + ")" + } + return s +} diff --git a/types/geography.go b/types/geography.go index 28c39a5..f9ca47d 100644 --- a/types/geography.go +++ b/types/geography.go @@ -24,62 +24,62 @@ func GeographyFromPointer(p unsafe.Pointer) *Geography { } // GeographyFromHexEWKB is MEOS geog_from_hexewkb. -func GeographyFromHexEWKB(hexwkb string) (*TRGeometrySeqSet, error) { +func GeographyFromHexEWKB(hexwkb string) (*Geo, error) { _r0, _err := functions.GeogFromHexewkb(hexwkb) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // GeographyIn is MEOS geog_in. -func GeographyIn(str string, typmod int32) (*TRGeometrySeqSet, error) { +func GeographyIn(str string, typmod int32) (*Geo, error) { _r0, _err := functions.GeogIn(str, typmod) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeographyToGeom is MEOS geog_to_geom. -func GeographyToGeom(geog *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeogToGeom(functions.GeomFromPointer(geog.Pointer())) +// ToGeom is MEOS geog_to_geom. +func (x *Geography) ToGeom() (*Geo, error) { + _r0, _err := functions.GeogToGeom(functions.GeomFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeographyArea is MEOS geog_area. -func GeographyArea(gs *TRGeometrySeqSet, use_spheroid bool) (float64, error) { - _r0, _err := functions.GeogArea(functions.GeomFromPointer(gs.Pointer()), use_spheroid) +// Area is MEOS geog_area. +func (x *Geography) Area(use_spheroid bool) (float64, error) { + _r0, _err := functions.GeogArea(functions.GeomFromPointer(x.Pointer()), use_spheroid) if _err != nil { return 0, _err } return _r0, nil } -// GeographyCentroid is MEOS geog_centroid. -func GeographyCentroid(gs *TRGeometrySeqSet, use_spheroid bool) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeogCentroid(functions.GeomFromPointer(gs.Pointer()), use_spheroid) +// Centroid is MEOS geog_centroid. +func (x *Geography) Centroid(use_spheroid bool) (*Geo, error) { + _r0, _err := functions.GeogCentroid(functions.GeomFromPointer(x.Pointer()), use_spheroid) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeographyLength is MEOS geog_length. -func GeographyLength(gs *TRGeometrySeqSet, use_spheroid bool) (float64, error) { - _r0, _err := functions.GeogLength(functions.GeomFromPointer(gs.Pointer()), use_spheroid) +// Length is MEOS geog_length. +func (x *Geography) Length(use_spheroid bool) (float64, error) { + _r0, _err := functions.GeogLength(functions.GeomFromPointer(x.Pointer()), use_spheroid) if _err != nil { return 0, _err } return _r0, nil } -// GeographyPerimeter is MEOS geog_perimeter. -func GeographyPerimeter(gs *TRGeometrySeqSet, use_spheroid bool) (float64, error) { - _r0, _err := functions.GeogPerimeter(functions.GeomFromPointer(gs.Pointer()), use_spheroid) +// Perimeter is MEOS geog_perimeter. +func (x *Geography) Perimeter(use_spheroid bool) (float64, error) { + _r0, _err := functions.GeogPerimeter(functions.GeomFromPointer(x.Pointer()), use_spheroid) if _err != nil { return 0, _err } @@ -87,70 +87,87 @@ func GeographyPerimeter(gs *TRGeometrySeqSet, use_spheroid bool) (float64, error } // GeographyArrayUnion is MEOS geog_array_union. -func GeographyArrayUnion(gsarr unsafe.Pointer, count int) (*TRGeometrySeqSet, error) { +func GeographyArrayUnion(gsarr unsafe.Pointer, count int) (*Geo, error) { _r0, _err := functions.GeogArrayUnion(gsarr, count) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeographyDwithin is MEOS geog_dwithin. -func GeographyDwithin(g1 *TRGeometrySeqSet, g2 *TRGeometrySeqSet, tolerance float64, use_spheroid bool) (bool, error) { - _r0, _err := functions.GeogDwithin(functions.GeomFromPointer(g1.Pointer()), functions.GeomFromPointer(g2.Pointer()), tolerance, use_spheroid) +// Dwithin is MEOS geog_dwithin. +func (x *Geography) Dwithin(g2 *Geo, tolerance float64, use_spheroid bool) (bool, error) { + _r0, _err := functions.GeogDwithin(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(g2.Pointer()), tolerance, use_spheroid) if _err != nil { return false, _err } return _r0, nil } -// GeographyDisjoint is MEOS geog_disjoint. -func GeographyDisjoint(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet, use_spheroid bool) (bool, error) { - _r0, _err := functions.GeogDisjoint(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer()), use_spheroid) +// Disjoint is MEOS geog_disjoint. +func (x *Geography) Disjoint(gs2 *Geo, use_spheroid bool) (bool, error) { + _r0, _err := functions.GeogDisjoint(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer()), use_spheroid) if _err != nil { return false, _err } return _r0, nil } -// GeographyIntersects is MEOS geog_intersects. -func GeographyIntersects(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet, use_spheroid bool) (bool, error) { - _r0, _err := functions.GeogIntersects(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer()), use_spheroid) +// Intersects is MEOS geog_intersects. +func (x *Geography) Intersects(gs2 *Geo, use_spheroid bool) (bool, error) { + _r0, _err := functions.GeogIntersects(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer()), use_spheroid) if _err != nil { return false, _err } return _r0, nil } -// GeographyDistance is MEOS geog_distance. -func GeographyDistance(g1 *TRGeometrySeqSet, g2 *TRGeometrySeqSet, use_spheroid bool) (float64, error) { - _r0, _err := functions.GeogDistance(functions.GeomFromPointer(g1.Pointer()), functions.GeomFromPointer(g2.Pointer()), use_spheroid) +// Distance is MEOS geog_distance. +func (x *Geography) Distance(g2 *Geo, use_spheroid bool) (float64, error) { + _r0, _err := functions.GeogDistance(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(g2.Pointer()), use_spheroid) if _err != nil { return 0, _err } return _r0, nil } -// GeographyShortestline is MEOS geog_shortestline. -func GeographyShortestline(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet, use_spheroid bool) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeogShortestline(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer()), use_spheroid) +// Shortestline is MEOS geog_shortestline. +func (x *Geography) Shortestline(gs2 *Geo, use_spheroid bool) (*Geo, error) { + _r0, _err := functions.GeogShortestline(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer()), use_spheroid) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // GeographyFromEWKB is the portable fromEWKB of MEOS geo_from_ewkb. -func GeographyFromEWKB(wkb []byte, srid int32) (*TRGeometrySeqSet, error) { - return GeoFromEWKB(wkb, srid) +func GeographyFromEWKB(wkb []byte, srid int32) (*Geography, error) { + r, err := GeoFromEWKB(wkb, srid) + if err != nil || r == nil { + return nil, err + } + return GeographyFromPointer(r.Pointer()), nil +} + +// AsMFJSON is the portable asMFJSON of MEOS geo_as_geojson. +func (x *Geography) AsMFJSON(option int, precision int, srs *string) (string, error) { + return x.AsGeoJSON(option, precision, srs) } // GeographyFromMFJSON is the portable fromMFJSON of MEOS geo_from_geojson. -func GeographyFromMFJSON(geojson string) (*TRGeometrySeqSet, error) { - return GeoFromGeoJSON(geojson) +func GeographyFromMFJSON(geojson string) (*Geography, error) { + r, err := GeoFromGeoJSON(geojson) + if err != nil || r == nil { + return nil, err + } + return GeographyFromPointer(r.Pointer()), nil } // GeographyFromText is the portable fromText of MEOS geo_from_text. -func GeographyFromText(wkt string, srid int32) (*TRGeometrySeqSet, error) { - return GeoFromText(wkt, srid) +func GeographyFromText(wkt string, srid int32) (*Geography, error) { + r, err := GeoFromText(wkt, srid) + if err != nil || r == nil { + return nil, err + } + return GeographyFromPointer(r.Pointer()), nil } diff --git a/types/geometry.go b/types/geometry.go index 28f826d..aa30a25 100644 --- a/types/geometry.go +++ b/types/geometry.go @@ -24,35 +24,35 @@ func GeometryFromPointer(p unsafe.Pointer) *Geometry { } // GeometryFromHexEWKB is MEOS geom_from_hexewkb. -func GeometryFromHexEWKB(hexwkb string) (*TRGeometrySeqSet, error) { +func GeometryFromHexEWKB(hexwkb string) (*Geo, error) { _r0, _err := functions.GeomFromHexewkb(hexwkb) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // GeometryIn is MEOS geom_in. -func GeometryIn(str string, typmod int32) (*TRGeometrySeqSet, error) { +func GeometryIn(str string, typmod int32) (*Geo, error) { _r0, _err := functions.GeomIn(str, typmod) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeometryToGeog is MEOS geom_to_geog. -func GeometryToGeog(geom *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeomToGeog(functions.GeomFromPointer(geom.Pointer())) +// ToGeog is MEOS geom_to_geog. +func (x *Geometry) ToGeog() (*Geo, error) { + _r0, _err := functions.GeomToGeog(functions.GeomFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeometryAzimuth is MEOS geom_azimuth. -func GeometryAzimuth(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (float64, bool, error) { - _found, _value, _err := functions.GeomAzimuth(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Azimuth is MEOS geom_azimuth. +func (x *Geometry) Azimuth(gs2 *Geo) (float64, bool, error) { + _found, _value, _err := functions.GeomAzimuth(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return 0, false, _err } @@ -62,27 +62,27 @@ func GeometryAzimuth(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (float64, boo return _value, true, nil } -// GeometryArea is MEOS geom_area. -func GeometryArea(gs *TRGeometrySeqSet) (float64, error) { - _r0, _err := functions.GeomArea(functions.GeomFromPointer(gs.Pointer())) +// Area is MEOS geom_area. +func (x *Geometry) Area() (float64, error) { + _r0, _err := functions.GeomArea(functions.GeomFromPointer(x.Pointer())) if _err != nil { return 0, _err } return _r0, nil } -// GeometryLength is MEOS geom_length. -func GeometryLength(gs *TRGeometrySeqSet) (float64, error) { - _r0, _err := functions.GeomLength(functions.GeomFromPointer(gs.Pointer())) +// Length is MEOS geom_length. +func (x *Geometry) Length() (float64, error) { + _r0, _err := functions.GeomLength(functions.GeomFromPointer(x.Pointer())) if _err != nil { return 0, _err } return _r0, nil } -// GeometryPerimeter is MEOS geom_perimeter. -func GeometryPerimeter(gs *TRGeometrySeqSet) (float64, error) { - _r0, _err := functions.GeomPerimeter(functions.GeomFromPointer(gs.Pointer())) +// Perimeter is MEOS geom_perimeter. +func (x *Geometry) Perimeter() (float64, error) { + _r0, _err := functions.GeomPerimeter(functions.GeomFromPointer(x.Pointer())) if _err != nil { return 0, _err } @@ -90,350 +90,350 @@ func GeometryPerimeter(gs *TRGeometrySeqSet) (float64, error) { } // GeometryArrayUnion is MEOS geom_array_union. -func GeometryArrayUnion(gsarr unsafe.Pointer, count int) (*TRGeometrySeqSet, error) { +func GeometryArrayUnion(gsarr unsafe.Pointer, count int) (*Geo, error) { _r0, _err := functions.GeomArrayUnion(gsarr, count) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeometryBoundary is MEOS geom_boundary. -func GeometryBoundary(gs *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeomBoundary(functions.GeomFromPointer(gs.Pointer())) +// Boundary is MEOS geom_boundary. +func (x *Geometry) Boundary() (*Geo, error) { + _r0, _err := functions.GeomBoundary(functions.GeomFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeometryBuffer is MEOS geom_buffer. -func GeometryBuffer(gs *TRGeometrySeqSet, size float64, params string) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeomBuffer(functions.GeomFromPointer(gs.Pointer()), size, params) +// Buffer is MEOS geom_buffer. +func (x *Geometry) Buffer(size float64, params string) (*Geo, error) { + _r0, _err := functions.GeomBuffer(functions.GeomFromPointer(x.Pointer()), size, params) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeometryCentroid is MEOS geom_centroid. -func GeometryCentroid(gs *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeomCentroid(functions.GeomFromPointer(gs.Pointer())) +// Centroid is MEOS geom_centroid. +func (x *Geometry) Centroid() (*Geo, error) { + _r0, _err := functions.GeomCentroid(functions.GeomFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeometryConvexHull is MEOS geom_convex_hull. -func GeometryConvexHull(gs *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeomConvexHull(functions.GeomFromPointer(gs.Pointer())) +// ConvexHull is MEOS geom_convex_hull. +func (x *Geometry) ConvexHull() (*Geo, error) { + _r0, _err := functions.GeomConvexHull(functions.GeomFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeometryDifference2d is MEOS geom_difference2d. -func GeometryDifference2d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeomDifference2d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Difference2d is MEOS geom_difference2d. +func (x *Geometry) Difference2d(gs2 *Geo) (*Geo, error) { + _r0, _err := functions.GeomDifference2d(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeometryIsSimple is MEOS geom_is_simple. -func GeometryIsSimple(gs *TRGeometrySeqSet) (bool, error) { - _r0, _err := functions.GeomIsSimple(functions.GeomFromPointer(gs.Pointer())) +// IsSimple is MEOS geom_is_simple. +func (x *Geometry) IsSimple() (bool, error) { + _r0, _err := functions.GeomIsSimple(functions.GeomFromPointer(x.Pointer())) if _err != nil { return false, _err } return _r0, nil } -// GeometryIntersection2d is MEOS geom_intersection2d. -func GeometryIntersection2d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeomIntersection2d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Intersection2d is MEOS geom_intersection2d. +func (x *Geometry) Intersection2d(gs2 *Geo) (*Geo, error) { + _r0, _err := functions.GeomIntersection2d(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeometryIntersection2dColl is MEOS geom_intersection2d_coll. -func GeometryIntersection2dColl(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeomIntersection2dColl(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Intersection2dColl is MEOS geom_intersection2d_coll. +func (x *Geometry) Intersection2dColl(gs2 *Geo) (*Geo, error) { + _r0, _err := functions.GeomIntersection2dColl(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeometryMinimumBoundingRadius is MEOS geom_minimum_bounding_radius. -func GeometryMinimumBoundingRadius(geom *TRGeometrySeqSet, radius unsafe.Pointer) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeomMinimumBoundingRadius(functions.GeomFromPointer(geom.Pointer()), radius) +// MinimumBoundingRadius is MEOS geom_minimum_bounding_radius. +func (x *Geometry) MinimumBoundingRadius(radius unsafe.Pointer) (*Geo, error) { + _r0, _err := functions.GeomMinimumBoundingRadius(functions.GeomFromPointer(x.Pointer()), radius) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeometryOrientedEnvelope is MEOS geom_oriented_envelope. -func GeometryOrientedEnvelope(gs *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeomOrientedEnvelope(functions.GeomFromPointer(gs.Pointer())) +// OrientedEnvelope is MEOS geom_oriented_envelope. +func (x *Geometry) OrientedEnvelope() (*Geo, error) { + _r0, _err := functions.GeomOrientedEnvelope(functions.GeomFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeometryShortestline is MEOS geom_shortestline. -func GeometryShortestline(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeomShortestline(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Shortestline is MEOS geom_shortestline. +func (x *Geometry) Shortestline(gs2 *Geo) (*Geo, error) { + _r0, _err := functions.GeomShortestline(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeometryShortestline2d is MEOS geom_shortestline2d. -func GeometryShortestline2d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeomShortestline2d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Shortestline2d is MEOS geom_shortestline2d. +func (x *Geometry) Shortestline2d(gs2 *Geo) (*Geo, error) { + _r0, _err := functions.GeomShortestline2d(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeometryShortestline3d is MEOS geom_shortestline3d. -func GeometryShortestline3d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeomShortestline3d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Shortestline3d is MEOS geom_shortestline3d. +func (x *Geometry) Shortestline3d(gs2 *Geo) (*Geo, error) { + _r0, _err := functions.GeomShortestline3d(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeometrySymdifference2d is MEOS geom_symdifference2d. -func GeometrySymdifference2d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeomSymdifference2d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Symdifference2d is MEOS geom_symdifference2d. +func (x *Geometry) Symdifference2d(gs2 *Geo) (*Geo, error) { + _r0, _err := functions.GeomSymdifference2d(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeometryUnaryUnion is MEOS geom_unary_union. -func GeometryUnaryUnion(gs *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeomUnaryUnion(functions.GeomFromPointer(gs.Pointer())) +// UnaryUnion is MEOS geom_unary_union. +func (x *Geometry) UnaryUnion() (*Geo, error) { + _r0, _err := functions.GeomUnaryUnion(functions.GeomFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeometryUnion2d is MEOS geom_union2d. -func GeometryUnion2d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeomUnion2d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Union2d is MEOS geom_union2d. +func (x *Geometry) Union2d(gs2 *Geo) (*Geo, error) { + _r0, _err := functions.GeomUnion2d(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } -// GeometryContains is MEOS geom_contains. -func GeometryContains(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (bool, error) { - _r0, _err := functions.GeomContains(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Contains is MEOS geom_contains. +func (x *Geometry) Contains(gs2 *Geo) (bool, error) { + _r0, _err := functions.GeomContains(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return false, _err } return _r0, nil } -// GeometryCovers is MEOS geom_covers. -func GeometryCovers(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (bool, error) { - _r0, _err := functions.GeomCovers(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Covers is MEOS geom_covers. +func (x *Geometry) Covers(gs2 *Geo) (bool, error) { + _r0, _err := functions.GeomCovers(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return false, _err } return _r0, nil } -// GeometryDisjoint is MEOS geom_disjoint. -func GeometryDisjoint(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (bool, error) { - _r0, _err := functions.GeomDisjoint(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Disjoint is MEOS geom_disjoint. +func (x *Geometry) Disjoint(gs2 *Geo) (bool, error) { + _r0, _err := functions.GeomDisjoint(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return false, _err } return _r0, nil } -// GeometryDisjoint2d is MEOS geom_disjoint2d. -func GeometryDisjoint2d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (bool, error) { - _r0, _err := functions.GeomDisjoint2d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Disjoint2d is MEOS geom_disjoint2d. +func (x *Geometry) Disjoint2d(gs2 *Geo) (bool, error) { + _r0, _err := functions.GeomDisjoint2d(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return false, _err } return _r0, nil } -// GeometryDwithin is MEOS geom_dwithin. -func GeometryDwithin(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet, tolerance float64) (bool, error) { - _r0, _err := functions.GeomDwithin(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer()), tolerance) +// Dwithin is MEOS geom_dwithin. +func (x *Geometry) Dwithin(gs2 *Geo, tolerance float64) (bool, error) { + _r0, _err := functions.GeomDwithin(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer()), tolerance) if _err != nil { return false, _err } return _r0, nil } -// GeometryDwithin2d is MEOS geom_dwithin2d. -func GeometryDwithin2d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet, tolerance float64) (bool, error) { - _r0, _err := functions.GeomDwithin2d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer()), tolerance) +// Dwithin2d is MEOS geom_dwithin2d. +func (x *Geometry) Dwithin2d(gs2 *Geo, tolerance float64) (bool, error) { + _r0, _err := functions.GeomDwithin2d(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer()), tolerance) if _err != nil { return false, _err } return _r0, nil } -// GeometryDwithin3d is MEOS geom_dwithin3d. -func GeometryDwithin3d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet, tolerance float64) (bool, error) { - _r0, _err := functions.GeomDwithin3d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer()), tolerance) +// Dwithin3d is MEOS geom_dwithin3d. +func (x *Geometry) Dwithin3d(gs2 *Geo, tolerance float64) (bool, error) { + _r0, _err := functions.GeomDwithin3d(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer()), tolerance) if _err != nil { return false, _err } return _r0, nil } -// GeometryIntersects is MEOS geom_intersects. -func GeometryIntersects(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (bool, error) { - _r0, _err := functions.GeomIntersects(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Intersects is MEOS geom_intersects. +func (x *Geometry) Intersects(gs2 *Geo) (bool, error) { + _r0, _err := functions.GeomIntersects(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return false, _err } return _r0, nil } -// GeometryIntersects2d is MEOS geom_intersects2d. -func GeometryIntersects2d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (bool, error) { - _r0, _err := functions.GeomIntersects2d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Intersects2d is MEOS geom_intersects2d. +func (x *Geometry) Intersects2d(gs2 *Geo) (bool, error) { + _r0, _err := functions.GeomIntersects2d(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return false, _err } return _r0, nil } -// GeometryIntersects3d is MEOS geom_intersects3d. -func GeometryIntersects3d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (bool, error) { - _r0, _err := functions.GeomIntersects3d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Intersects3d is MEOS geom_intersects3d. +func (x *Geometry) Intersects3d(gs2 *Geo) (bool, error) { + _r0, _err := functions.GeomIntersects3d(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return false, _err } return _r0, nil } -// GeometryRelate is MEOS geom_relate. -func GeometryRelate(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (string, error) { - _r0, _err := functions.GeomRelate(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Relate is MEOS geom_relate. +func (x *Geometry) Relate(gs2 *Geo) (string, error) { + _r0, _err := functions.GeomRelate(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return "", _err } return _r0, nil } -// GeometryRelatePattern is MEOS geom_relate_pattern. -func GeometryRelatePattern(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet, patt string) (bool, error) { - _r0, _err := functions.GeomRelatePattern(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer()), patt) +// RelatePattern is MEOS geom_relate_pattern. +func (x *Geometry) RelatePattern(gs2 *Geo, patt string) (bool, error) { + _r0, _err := functions.GeomRelatePattern(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer()), patt) if _err != nil { return false, _err } return _r0, nil } -// GeometryTouches is MEOS geom_touches. -func GeometryTouches(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (bool, error) { - _r0, _err := functions.GeomTouches(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Touches is MEOS geom_touches. +func (x *Geometry) Touches(gs2 *Geo) (bool, error) { + _r0, _err := functions.GeomTouches(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return false, _err } return _r0, nil } -// GeometryDistance is MEOS geom_distance. -func GeometryDistance(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (float64, error) { - _r0, _err := functions.GeomDistance(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Distance is MEOS geom_distance. +func (x *Geometry) Distance(gs2 *Geo) (float64, error) { + _r0, _err := functions.GeomDistance(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return 0, _err } return _r0, nil } -// GeometryDistance2d is MEOS geom_distance2d. -func GeometryDistance2d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (float64, error) { - _r0, _err := functions.GeomDistance2d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Distance2d is MEOS geom_distance2d. +func (x *Geometry) Distance2d(gs2 *Geo) (float64, error) { + _r0, _err := functions.GeomDistance2d(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return 0, _err } return _r0, nil } -// GeometryMaxDistance is MEOS geom_max_distance. -func GeometryMaxDistance(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (float64, error) { - _r0, _err := functions.GeomMaxDistance(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// MaxDistance is MEOS geom_max_distance. +func (x *Geometry) MaxDistance(gs2 *Geo) (float64, error) { + _r0, _err := functions.GeomMaxDistance(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return 0, _err } return _r0, nil } -// GeometryMaxDistance2d is MEOS geom_max_distance2d. -func GeometryMaxDistance2d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (float64, error) { - _r0, _err := functions.GeomMaxDistance2d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// MaxDistance2d is MEOS geom_max_distance2d. +func (x *Geometry) MaxDistance2d(gs2 *Geo) (float64, error) { + _r0, _err := functions.GeomMaxDistance2d(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return 0, _err } return _r0, nil } -// GeometryMaxDistance3d is MEOS geom_max_distance3d. -func GeometryMaxDistance3d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (float64, error) { - _r0, _err := functions.GeomMaxDistance3d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// MaxDistance3d is MEOS geom_max_distance3d. +func (x *Geometry) MaxDistance3d(gs2 *Geo) (float64, error) { + _r0, _err := functions.GeomMaxDistance3d(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return 0, _err } return _r0, nil } -// GeometryDistance3d is MEOS geom_distance3d. -func GeometryDistance3d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (float64, error) { - _r0, _err := functions.GeomDistance3d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) +// Distance3d is MEOS geom_distance3d. +func (x *Geometry) Distance3d(gs2 *Geo) (float64, error) { + _r0, _err := functions.GeomDistance3d(functions.GeomFromPointer(x.Pointer()), functions.GeomFromPointer(gs2.Pointer())) if _err != nil { return 0, _err } return _r0, nil } -// GeometryToCbuffer is MEOS geom_to_cbuffer. -func GeometryToCbuffer(gs *TRGeometrySeqSet) (*Cbuffer, error) { - _r0, _err := functions.GeomToCbuffer(functions.GeomFromPointer(gs.Pointer())) +// ToCbuffer is MEOS geom_to_cbuffer. +func (x *Geometry) ToCbuffer() (*Cbuffer, error) { + _r0, _err := functions.GeomToCbuffer(functions.GeomFromPointer(x.Pointer())) if _err != nil { return nil, _err } return CbufferFromPointer(_r0.Pointer()), nil } -// GeometryToNsegment is MEOS geom_to_nsegment. -func GeometryToNsegment(gs *TRGeometrySeqSet) (*Nsegment, error) { - _r0, _err := functions.GeomToNsegment(functions.GeomFromPointer(gs.Pointer())) +// ToNsegment is MEOS geom_to_nsegment. +func (x *Geometry) ToNsegment() (*Nsegment, error) { + _r0, _err := functions.GeomToNsegment(functions.GeomFromPointer(x.Pointer())) if _err != nil { return nil, _err } return NsegmentFromPointer(_r0.Pointer()), nil } -// GeometryTposeToTrgeometry is MEOS geometry_tpose_to_trgeometry. -func GeometryTposeToTrgeometry(gs *TRGeometrySeqSet, temp *Temporal) (*Temporal, error) { - _r0, _err := functions.GeometryTposeToTrgeometry(functions.GeomFromPointer(gs.Pointer()), functions.TemporalFromPointer(temp.Pointer())) +// TposeToTrgeometry is MEOS geometry_tpose_to_trgeometry. +func (x *Geometry) TposeToTrgeometry(temp *Temporal) (*Temporal, error) { + _r0, _err := functions.GeometryTposeToTrgeometry(functions.GeomFromPointer(x.Pointer()), functions.TemporalFromPointer(temp.Pointer())) if _err != nil { return nil, _err } @@ -441,16 +441,33 @@ func GeometryTposeToTrgeometry(gs *TRGeometrySeqSet, temp *Temporal) (*Temporal, } // GeometryFromEWKB is the portable fromEWKB of MEOS geo_from_ewkb. -func GeometryFromEWKB(wkb []byte, srid int32) (*TRGeometrySeqSet, error) { - return GeoFromEWKB(wkb, srid) +func GeometryFromEWKB(wkb []byte, srid int32) (*Geometry, error) { + r, err := GeoFromEWKB(wkb, srid) + if err != nil || r == nil { + return nil, err + } + return GeometryFromPointer(r.Pointer()), nil +} + +// AsMFJSON is the portable asMFJSON of MEOS geo_as_geojson. +func (x *Geometry) AsMFJSON(option int, precision int, srs *string) (string, error) { + return x.AsGeoJSON(option, precision, srs) } // GeometryFromMFJSON is the portable fromMFJSON of MEOS geo_from_geojson. -func GeometryFromMFJSON(geojson string) (*TRGeometrySeqSet, error) { - return GeoFromGeoJSON(geojson) +func GeometryFromMFJSON(geojson string) (*Geometry, error) { + r, err := GeoFromGeoJSON(geojson) + if err != nil || r == nil { + return nil, err + } + return GeometryFromPointer(r.Pointer()), nil } // GeometryFromText is the portable fromText of MEOS geo_from_text. -func GeometryFromText(wkt string, srid int32) (*TRGeometrySeqSet, error) { - return GeoFromText(wkt, srid) +func GeometryFromText(wkt string, srid int32) (*Geometry, error) { + r, err := GeoFromText(wkt, srid) + if err != nil || r == nil { + return nil, err + } + return GeometryFromPointer(r.Pointer()), nil } diff --git a/types/geoset.go b/types/geoset.go index e083748..104d1b0 100644 --- a/types/geoset.go +++ b/types/geoset.go @@ -33,34 +33,34 @@ func GeoSetMake(values unsafe.Pointer, count int) (*Set, error) { } // ToGeo is MEOS geoset_to_geo. -func (x *GeoSet) ToGeo() (*TRGeometrySeqSet, error) { +func (x *GeoSet) ToGeo() (*Geo, error) { _r0, _err := functions.GeosetToGeo(functions.SetFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // EndValue is MEOS geoset_end_value. -func (x *GeoSet) EndValue() (*TRGeometrySeqSet, error) { +func (x *GeoSet) EndValue() (*Geo, error) { _r0, _err := functions.GeosetEndValue(functions.SetFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // StartValue is MEOS geoset_start_value. -func (x *GeoSet) StartValue() (*TRGeometrySeqSet, error) { +func (x *GeoSet) StartValue() (*Geo, error) { _r0, _err := functions.GeosetStartValue(functions.SetFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // ValueN is MEOS geoset_value_n. -func (x *GeoSet) ValueN(n int) (*TRGeometrySeqSet, bool, error) { +func (x *GeoSet) ValueN(n int) (*Geo, bool, error) { _found, _value, _err := functions.GeosetValueN(functions.SetFromPointer(x.Pointer()), n) if _err != nil { return nil, false, _err @@ -68,7 +68,7 @@ func (x *GeoSet) ValueN(n int) (*TRGeometrySeqSet, bool, error) { if !_found { return nil, false, nil } - return TRGeometrySeqSetFromPointer(_value.Pointer()), true, nil + return GeoFromPointer(_value.Pointer()), true, nil } // Values is MEOS geoset_values. diff --git a/types/npoint.go b/types/npoint.go index 7be8531..7dee5bf 100644 --- a/types/npoint.go +++ b/types/npoint.go @@ -140,12 +140,12 @@ func NpointMake(rid int64, pos float64) (*Npoint, error) { } // ToGeompoint is MEOS npoint_to_geompoint. -func (x *Npoint) ToGeompoint() (*TRGeometrySeqSet, error) { +func (x *Npoint) ToGeompoint() (*Geo, error) { _r0, _err := functions.NpointToGeompoint(functions.NpointFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // ToNsegment is MEOS npoint_to_nsegment. diff --git a/types/nsegment.go b/types/nsegment.go index e164d84..b026d6e 100644 --- a/types/nsegment.go +++ b/types/nsegment.go @@ -140,12 +140,12 @@ func NsegmentMake(rid int64, pos1 float64, pos2 float64) (*Nsegment, error) { } // ToGeom is MEOS nsegment_to_geom. -func (x *Nsegment) ToGeom() (*TRGeometrySeqSet, error) { +func (x *Nsegment) ToGeom() (*Geo, error) { _r0, _err := functions.NsegmentToGeom(functions.NsegmentFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // ToStbox is MEOS nsegment_to_stbox. diff --git a/types/pcpatch.go b/types/pcpatch.go index 155e1db..aa4fbda 100644 --- a/types/pcpatch.go +++ b/types/pcpatch.go @@ -150,12 +150,12 @@ func (x *Pcpatch) MemSize() (int, error) { } // ToGeom is MEOS pcpatch_to_geom. -func (x *Pcpatch) ToGeom() (*TRGeometrySeqSet, error) { +func (x *Pcpatch) ToGeom() (*Geo, error) { _r0, _err := functions.PcpatchToGeom(functions.PcpatchFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // Cmp is MEOS pcpatch_cmp. diff --git a/types/pose.go b/types/pose.go index 8a314d5..f543458 100644 --- a/types/pose.go +++ b/types/pose.go @@ -149,12 +149,12 @@ func (x *Pose) AsGeopose(conformance int, precision int) (string, error) { } // ApplyGeo is MEOS pose_apply_geo. -func (x *Pose) ApplyGeo(body *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { +func (x *Pose) ApplyGeo(body *Geo) (*Geo, error) { _r0, _err := functions.PoseApplyGeo(functions.PoseFromPointer(x.Pointer()), functions.GeomFromPointer(body.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // ComposeTpose is MEOS pose_compose_tpose. @@ -194,7 +194,7 @@ func PoseMake3d(x float64, y float64, z float64, W float64, X float64, Y float64 } // PoseMakePoint2d is MEOS pose_make_point2d. -func PoseMakePoint2d(gs *TRGeometrySeqSet, theta float64) (*Pose, error) { +func PoseMakePoint2d(gs *Geo, theta float64) (*Pose, error) { _r0, _err := functions.PoseMakePoint2d(functions.GeomFromPointer(gs.Pointer()), theta) if _err != nil { return nil, _err @@ -203,7 +203,7 @@ func PoseMakePoint2d(gs *TRGeometrySeqSet, theta float64) (*Pose, error) { } // PoseMakePoint3d is MEOS pose_make_point3d. -func PoseMakePoint3d(gs *TRGeometrySeqSet, W float64, X float64, Y float64, Z float64) (*Pose, error) { +func PoseMakePoint3d(gs *Geo, W float64, X float64, Y float64, Z float64) (*Pose, error) { _r0, _err := functions.PoseMakePoint3d(functions.GeomFromPointer(gs.Pointer()), W, X, Y, Z) if _err != nil { return nil, _err @@ -212,7 +212,7 @@ func PoseMakePoint3d(gs *TRGeometrySeqSet, W float64, X float64, Y float64, Z fl } // PoseMakePoint3dYpr is MEOS pose_make_point3d_ypr. -func PoseMakePoint3dYpr(gs *TRGeometrySeqSet, yaw float64, pitch float64, roll float64) (*Pose, error) { +func PoseMakePoint3dYpr(gs *Geo, yaw float64, pitch float64, roll float64) (*Pose, error) { _r0, _err := functions.PoseMakePoint3dYpr(functions.GeomFromPointer(gs.Pointer()), yaw, pitch, roll) if _err != nil { return nil, _err @@ -221,12 +221,12 @@ func PoseMakePoint3dYpr(gs *TRGeometrySeqSet, yaw float64, pitch float64, roll f } // ToPoint is MEOS pose_to_point. -func (x *Pose) ToPoint() (*TRGeometrySeqSet, error) { +func (x *Pose) ToPoint() (*Geo, error) { _r0, _err := functions.PoseToPoint(functions.PoseFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // ToStbox is MEOS pose_to_stbox. diff --git a/types/posechain.go b/types/posechain.go index 6218370..3ed21fe 100644 --- a/types/posechain.go +++ b/types/posechain.go @@ -167,12 +167,12 @@ func PoseChainPrefixPose(pc unsafe.Pointer, n int) (*Pose, error) { } // PoseChainToPoint is MEOS posechain_to_point. -func PoseChainToPoint(pc unsafe.Pointer) (*TRGeometrySeqSet, error) { +func PoseChainToPoint(pc unsafe.Pointer) (*Geo, error) { _r0, _err := functions.PosechainToPoint(pc) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // PoseChainToStbox is MEOS posechain_to_stbox. diff --git a/types/raster.go b/types/raster.go index 4d81246..67af982 100644 --- a/types/raster.go +++ b/types/raster.go @@ -254,7 +254,7 @@ func RasterBandPixels(rast unsafe.Pointer, band int) ([]byte, error) { } // RasterClip is MEOS raster_clip. -func RasterClip(rast unsafe.Pointer, bands unsafe.Pointer, nbands int, gs *TRGeometrySeqSet, nodata unsafe.Pointer, nnodata int, crop bool, touched bool) (unsafe.Pointer, error) { +func RasterClip(rast unsafe.Pointer, bands unsafe.Pointer, nbands int, gs *Geo, nodata unsafe.Pointer, nnodata int, crop bool, touched bool) (unsafe.Pointer, error) { _r0, _err := functions.RasterClip(rast, bands, nbands, functions.GeomFromPointer(gs.Pointer()), nodata, nnodata, crop, touched) if _err != nil { return nil, _err diff --git a/types/stbox.go b/types/stbox.go index 7f47165..7c3dbad 100644 --- a/types/stbox.go +++ b/types/stbox.go @@ -122,12 +122,12 @@ func STBoxMake(hasx bool, hasz bool, geodetic bool, srid int32, xmin float64, xm } // ToGeo is MEOS stbox_to_geo. -func (x *STBox) ToGeo() (*TRGeometrySeqSet, error) { +func (x *STBox) ToGeo() (*Geo, error) { _r0, _err := functions.STBOXToGeo(functions.STBoxFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // ToTstzspan is MEOS stbox_to_tstzspan. @@ -495,7 +495,7 @@ func (x *STBox) SpatialDistance(box2 *STBox) (float64, error) { } // STBoxGetSpaceTile is MEOS stbox_get_space_tile. -func STBoxGetSpaceTile(point *TRGeometrySeqSet, xsize float64, ysize float64, zsize float64, sorigin *TRGeometrySeqSet) (*STBox, error) { +func STBoxGetSpaceTile(point *Geo, xsize float64, ysize float64, zsize float64, sorigin *Geo) (*STBox, error) { _r0, _err := functions.STBOXGetSpaceTile(functions.GeomFromPointer(point.Pointer()), xsize, ysize, zsize, functions.GeomFromPointer(sorigin.Pointer())) if _err != nil { return nil, _err @@ -504,7 +504,7 @@ func STBoxGetSpaceTile(point *TRGeometrySeqSet, xsize float64, ysize float64, zs } // SpaceTiles is MEOS stbox_space_tiles. -func (x *STBox) SpaceTiles(xsize float64, ysize float64, zsize float64, sorigin *TRGeometrySeqSet, border_inc bool, count unsafe.Pointer) (*STBox, error) { +func (x *STBox) SpaceTiles(xsize float64, ysize float64, zsize float64, sorigin *Geo, border_inc bool, count unsafe.Pointer) (*STBox, error) { _r0, _err := functions.STBOXSpaceTiles(functions.STBoxFromPointer(x.Pointer()), xsize, ysize, zsize, functions.GeomFromPointer(sorigin.Pointer()), border_inc, count) if _err != nil { return nil, _err diff --git a/types/tbigintinst.go b/types/tbigintinst.go index 45cfe60..0b4a17e 100644 --- a/types/tbigintinst.go +++ b/types/tbigintinst.go @@ -9,7 +9,7 @@ import ( ) type TBigintInst struct { - handle + TBigint } // TBigintInstFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tbigintseq.go b/types/tbigintseq.go index f0becf8..3491ed3 100644 --- a/types/tbigintseq.go +++ b/types/tbigintseq.go @@ -9,7 +9,7 @@ import ( ) type TBigintSeq struct { - handle + TBigint } // TBigintSeqFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tbigintseqset.go b/types/tbigintseqset.go index 8114759..744e917 100644 --- a/types/tbigintseqset.go +++ b/types/tbigintseqset.go @@ -9,7 +9,7 @@ import ( ) type TBigintSeqSet struct { - handle + TBigint } // TBigintSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tboolinst.go b/types/tboolinst.go index 7283456..68841f3 100644 --- a/types/tboolinst.go +++ b/types/tboolinst.go @@ -9,7 +9,7 @@ import ( ) type TBoolInst struct { - handle + TBool } // TBoolInstFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tboolseq.go b/types/tboolseq.go index 04812dc..ae0762b 100644 --- a/types/tboolseq.go +++ b/types/tboolseq.go @@ -9,7 +9,7 @@ import ( ) type TBoolSeq struct { - handle + TBool } // TBoolSeqFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tboolseqset.go b/types/tboolseqset.go index d20e57f..7e56695 100644 --- a/types/tboolseqset.go +++ b/types/tboolseqset.go @@ -9,7 +9,7 @@ import ( ) type TBoolSeqSet struct { - handle + TBool } // TBoolSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tcbuffer.go b/types/tcbuffer.go index bbf8b71..63bfbaf 100644 --- a/types/tcbuffer.go +++ b/types/tcbuffer.go @@ -87,21 +87,21 @@ func (x *TCbuffer) Radius() (*Set, error) { } // TraversedArea is MEOS tcbuffer_traversed_area. -func (x *TCbuffer) TraversedArea(unary_union bool) (*TRGeometrySeqSet, error) { +func (x *TCbuffer) TraversedArea(unary_union bool) (*Geo, error) { _r0, _err := functions.TcbufferTraversedArea(functions.TemporalFromPointer(x.Pointer()), unary_union) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // ConvexHull is MEOS tcbuffer_convex_hull. -func (x *TCbuffer) ConvexHull() (*TRGeometrySeqSet, error) { +func (x *TCbuffer) ConvexHull() (*Geo, error) { _r0, _err := functions.TcbufferConvexHull(functions.TemporalFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // StartValue is MEOS tcbuffer_start_value. @@ -228,7 +228,7 @@ func (x *TCbuffer) AtCbuffer(cb *Cbuffer) (*Temporal, error) { } // AtGeom is MEOS tcbuffer_at_geom. -func (x *TCbuffer) AtGeom(gs *TRGeometrySeqSet) (*Temporal, error) { +func (x *TCbuffer) AtGeom(gs *Geo) (*Temporal, error) { _r0, _err := functions.TcbufferAtGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) if _err != nil { return nil, _err @@ -255,7 +255,7 @@ func (x *TCbuffer) MinusCbuffer(cb *Cbuffer) (*Temporal, error) { } // MinusGeom is MEOS tcbuffer_minus_geom. -func (x *TCbuffer) MinusGeom(gs *TRGeometrySeqSet) (*Temporal, error) { +func (x *TCbuffer) MinusGeom(gs *Geo) (*Temporal, error) { _r0, _err := functions.TcbufferMinusGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) if _err != nil { return nil, _err diff --git a/types/tcbufferinst.go b/types/tcbufferinst.go index ab617ce..8e17614 100644 --- a/types/tcbufferinst.go +++ b/types/tcbufferinst.go @@ -9,7 +9,7 @@ import ( ) type TCbufferInst struct { - handle + TCbuffer } // TCbufferInstFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tcbufferseq.go b/types/tcbufferseq.go index a26ef1b..c44041d 100644 --- a/types/tcbufferseq.go +++ b/types/tcbufferseq.go @@ -9,7 +9,7 @@ import ( ) type TCbufferSeq struct { - handle + TCbuffer } // TCbufferSeqFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tcbufferseqset.go b/types/tcbufferseqset.go index 78b1845..a659ef5 100644 --- a/types/tcbufferseqset.go +++ b/types/tcbufferseqset.go @@ -9,7 +9,7 @@ import ( ) type TCbufferSeqSet struct { - handle + TCbuffer } // TCbufferSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tfloatinst.go b/types/tfloatinst.go index c5234f7..a3f7481 100644 --- a/types/tfloatinst.go +++ b/types/tfloatinst.go @@ -9,7 +9,7 @@ import ( ) type TFloatInst struct { - handle + TFloat } // TFloatInstFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tfloatseq.go b/types/tfloatseq.go index 94465c5..400bbae 100644 --- a/types/tfloatseq.go +++ b/types/tfloatseq.go @@ -9,7 +9,7 @@ import ( ) type TFloatSeq struct { - handle + TFloat } // TFloatSeqFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tfloatseqset.go b/types/tfloatseqset.go index c273222..af49712 100644 --- a/types/tfloatseqset.go +++ b/types/tfloatseqset.go @@ -9,7 +9,7 @@ import ( ) type TFloatSeqSet struct { - handle + TFloat } // TFloatSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tgeo.go b/types/tgeo.go index e63e970..941f515 100644 --- a/types/tgeo.go +++ b/types/tgeo.go @@ -26,7 +26,7 @@ func TGeoFromPointer(p unsafe.Pointer) *TGeo { } // TGeoFromBaseTemp is MEOS tgeo_from_base_temp. -func TGeoFromBaseTemp(gs *TRGeometrySeqSet, temp *Temporal) (*Temporal, error) { +func TGeoFromBaseTemp(gs *Geo, temp *Temporal) (*Temporal, error) { _r0, _err := functions.TgeoFromBaseTemp(functions.GeomFromPointer(gs.Pointer()), functions.TemporalFromPointer(temp.Pointer())) if _err != nil { return nil, _err @@ -44,52 +44,52 @@ func (x *TGeo) Centroid(spheroid bool) (*Temporal, error) { } // ConvexHull is MEOS tgeo_convex_hull. -func (x *TGeo) ConvexHull() (*TRGeometrySeqSet, error) { +func (x *TGeo) ConvexHull() (*Geo, error) { _r0, _err := functions.TgeoConvexHull(functions.TemporalFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // EndValue is MEOS tgeo_end_value. -func (x *TGeo) EndValue() (*TRGeometrySeqSet, error) { +func (x *TGeo) EndValue() (*Geo, error) { _r0, _err := functions.TgeoEndValue(functions.TemporalFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // StartValue is MEOS tgeo_start_value. -func (x *TGeo) StartValue() (*TRGeometrySeqSet, error) { +func (x *TGeo) StartValue() (*Geo, error) { _r0, _err := functions.TgeoStartValue(functions.TemporalFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // TraversedArea is MEOS tgeo_traversed_area. -func (x *TGeo) TraversedArea(unary_union bool) (*TRGeometrySeqSet, error) { +func (x *TGeo) TraversedArea(unary_union bool) (*Geo, error) { _r0, _err := functions.TgeoTraversedArea(functions.TemporalFromPointer(x.Pointer()), unary_union) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // Value is MEOS tgeo_value. -func (x *TGeo) Value() (*TRGeometrySeqSet, error) { +func (x *TGeo) Value() (*Geo, error) { _r0, _err := functions.TgeoValue(functions.TemporalFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // ValueAtTimestamptz is MEOS tgeo_value_at_timestamptz. -func (x *TGeo) ValueAtTimestamptz(t int64, strict bool) (*TRGeometrySeqSet, bool, error) { +func (x *TGeo) ValueAtTimestamptz(t int64, strict bool) (*Geo, bool, error) { _found, _value, _err := functions.TgeoValueAtTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, strict) if _err != nil { return nil, false, _err @@ -97,11 +97,11 @@ func (x *TGeo) ValueAtTimestamptz(t int64, strict bool) (*TRGeometrySeqSet, bool if !_found { return nil, false, nil } - return TRGeometrySeqSetFromPointer(_value.Pointer()), true, nil + return GeoFromPointer(_value.Pointer()), true, nil } // ValueN is MEOS tgeo_value_n. -func (x *TGeo) ValueN(n int) (*TRGeometrySeqSet, bool, error) { +func (x *TGeo) ValueN(n int) (*Geo, bool, error) { _found, _value, _err := functions.TgeoValueN(functions.TemporalFromPointer(x.Pointer()), n) if _err != nil { return nil, false, _err @@ -109,7 +109,7 @@ func (x *TGeo) ValueN(n int) (*TRGeometrySeqSet, bool, error) { if !_found { return nil, false, nil } - return TRGeometrySeqSetFromPointer(_value.Pointer()), true, nil + return GeoFromPointer(_value.Pointer()), true, nil } // Values is MEOS tgeo_values. @@ -149,7 +149,7 @@ func (x *TGeo) Rotate(angle float64, x0 float64, y0 float64) (*Temporal, error) } // RotateGeo is MEOS tgeo_rotate_geo. -func (x *TGeo) RotateGeo(angle float64, origin *TRGeometrySeqSet) (*Temporal, error) { +func (x *TGeo) RotateGeo(angle float64, origin *Geo) (*Temporal, error) { _r0, _err := functions.TgeoRotateGeo(functions.TemporalFromPointer(x.Pointer()), angle, functions.GeomFromPointer(origin.Pointer())) if _err != nil { return nil, _err @@ -194,7 +194,7 @@ func (x *TGeo) Scale(xfactor float64, yfactor float64, zfactor float64) (*Tempor } // ScaleGeo is MEOS tgeo_scale_geo. -func (x *TGeo) ScaleGeo(scale *TRGeometrySeqSet) (*Temporal, error) { +func (x *TGeo) ScaleGeo(scale *Geo) (*Temporal, error) { _r0, _err := functions.TgeoScaleGeo(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(scale.Pointer())) if _err != nil { return nil, _err @@ -203,7 +203,7 @@ func (x *TGeo) ScaleGeo(scale *TRGeometrySeqSet) (*Temporal, error) { } // ScaleGeoOrigin is MEOS tgeo_scale_geo_origin. -func (x *TGeo) ScaleGeoOrigin(scale *TRGeometrySeqSet, sorigin *TRGeometrySeqSet) (*Temporal, error) { +func (x *TGeo) ScaleGeoOrigin(scale *Geo, sorigin *Geo) (*Temporal, error) { _r0, _err := functions.TgeoScaleGeoOrigin(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(scale.Pointer()), functions.GeomFromPointer(sorigin.Pointer())) if _err != nil { return nil, _err @@ -230,7 +230,7 @@ func (x *TGeo) Transscale(deltax float64, deltay float64, xfactor float64, yfact } // AtGeom is MEOS tgeo_at_geom. -func (x *TGeo) AtGeom(gs *TRGeometrySeqSet) (*Temporal, error) { +func (x *TGeo) AtGeom(gs *Geo) (*Temporal, error) { _r0, _err := functions.TgeoAtGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) if _err != nil { return nil, _err @@ -248,7 +248,7 @@ func (x *TGeo) AtStbox(box *STBox, border_inc bool) (*Temporal, error) { } // AtValue is MEOS tgeo_at_value. -func (x *TGeo) AtValue(gs *TRGeometrySeqSet) (*Temporal, error) { +func (x *TGeo) AtValue(gs *Geo) (*Temporal, error) { _r0, _err := functions.TgeoAtValue(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) if _err != nil { return nil, _err @@ -257,7 +257,7 @@ func (x *TGeo) AtValue(gs *TRGeometrySeqSet) (*Temporal, error) { } // MinusGeom is MEOS tgeo_minus_geom. -func (x *TGeo) MinusGeom(gs *TRGeometrySeqSet) (*Temporal, error) { +func (x *TGeo) MinusGeom(gs *Geo) (*Temporal, error) { _r0, _err := functions.TgeoMinusGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) if _err != nil { return nil, _err @@ -275,7 +275,7 @@ func (x *TGeo) MinusStbox(box *STBox, border_inc bool) (*Temporal, error) { } // MinusValue is MEOS tgeo_minus_value. -func (x *TGeo) MinusValue(gs *TRGeometrySeqSet) (*Temporal, error) { +func (x *TGeo) MinusValue(gs *Geo) (*Temporal, error) { _r0, _err := functions.TgeoMinusValue(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) if _err != nil { return nil, _err @@ -293,7 +293,7 @@ func (x *TGeo) Stboxes(count unsafe.Pointer) (*STBox, error) { } // SpaceBoxes is MEOS tgeo_space_boxes. -func (x *TGeo) SpaceBoxes(xsize float64, ysize float64, zsize float64, sorigin *TRGeometrySeqSet, bitmatrix bool, border_inc bool, count unsafe.Pointer) (*STBox, error) { +func (x *TGeo) SpaceBoxes(xsize float64, ysize float64, zsize float64, sorigin *Geo, bitmatrix bool, border_inc bool, count unsafe.Pointer) (*STBox, error) { _r0, _err := functions.TgeoSpaceBoxes(functions.TemporalFromPointer(x.Pointer()), xsize, ysize, zsize, functions.GeomFromPointer(sorigin.Pointer()), bitmatrix, border_inc, count) if _err != nil { return nil, _err @@ -320,7 +320,7 @@ func (x *TGeo) SplitNStboxes(box_count int, count unsafe.Pointer) (*STBox, error } // SpaceSplit is MEOS tgeo_space_split. -func (x *TGeo) SpaceSplit(xsize float64, ysize float64, zsize float64, sorigin *TRGeometrySeqSet, bitmatrix bool, border_inc bool, space_bins unsafe.Pointer, count unsafe.Pointer) (unsafe.Pointer, error) { +func (x *TGeo) SpaceSplit(xsize float64, ysize float64, zsize float64, sorigin *Geo, bitmatrix bool, border_inc bool, space_bins unsafe.Pointer, count unsafe.Pointer) (unsafe.Pointer, error) { _r0, _err := functions.TgeoSpaceSplit(functions.TemporalFromPointer(x.Pointer()), xsize, ysize, zsize, functions.GeomFromPointer(sorigin.Pointer()), bitmatrix, border_inc, space_bins, count) if _err != nil { return nil, _err diff --git a/types/tgeogpointinst.go b/types/tgeogpointinst.go index d753a8b..b08b580 100644 --- a/types/tgeogpointinst.go +++ b/types/tgeogpointinst.go @@ -7,7 +7,7 @@ import ( ) type TGeogPointInst struct { - handle + TGeogPoint } // TGeogPointInstFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tgeogpointseq.go b/types/tgeogpointseq.go index 7c1f95c..e4c2a4c 100644 --- a/types/tgeogpointseq.go +++ b/types/tgeogpointseq.go @@ -7,7 +7,7 @@ import ( ) type TGeogPointSeq struct { - handle + TGeogPoint } // TGeogPointSeqFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tgeogpointseqset.go b/types/tgeogpointseqset.go index 54b493b..80e0959 100644 --- a/types/tgeogpointseqset.go +++ b/types/tgeogpointseqset.go @@ -7,7 +7,7 @@ import ( ) type TGeogPointSeqSet struct { - handle + TGeogPoint } // TGeogPointSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tgeographyinst.go b/types/tgeographyinst.go index a8f83c8..f59ee2e 100644 --- a/types/tgeographyinst.go +++ b/types/tgeographyinst.go @@ -7,7 +7,7 @@ import ( ) type TGeographyInst struct { - handle + TGeography } // TGeographyInstFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tgeographyseq.go b/types/tgeographyseq.go index 0876949..f67cb28 100644 --- a/types/tgeographyseq.go +++ b/types/tgeographyseq.go @@ -7,7 +7,7 @@ import ( ) type TGeographySeq struct { - handle + TGeography } // TGeographySeqFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tgeographyseqset.go b/types/tgeographyseqset.go index 68c4a8d..776de54 100644 --- a/types/tgeographyseqset.go +++ b/types/tgeographyseqset.go @@ -7,7 +7,7 @@ import ( ) type TGeographySeqSet struct { - handle + TGeography } // TGeographySeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tgeometryinst.go b/types/tgeometryinst.go index e9531c1..dee84b5 100644 --- a/types/tgeometryinst.go +++ b/types/tgeometryinst.go @@ -7,7 +7,7 @@ import ( ) type TGeometryInst struct { - handle + TGeometry } // TGeometryInstFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tgeometryseq.go b/types/tgeometryseq.go index f97adc6..f8d9cf3 100644 --- a/types/tgeometryseq.go +++ b/types/tgeometryseq.go @@ -7,7 +7,7 @@ import ( ) type TGeometrySeq struct { - handle + TGeometry } // TGeometrySeqFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tgeometryseqset.go b/types/tgeometryseqset.go index 2216ea5..dec5700 100644 --- a/types/tgeometryseqset.go +++ b/types/tgeometryseqset.go @@ -7,7 +7,7 @@ import ( ) type TGeometrySeqSet struct { - handle + TGeometry } // TGeometrySeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tgeompointinst.go b/types/tgeompointinst.go index 63ff788..80be8bd 100644 --- a/types/tgeompointinst.go +++ b/types/tgeompointinst.go @@ -7,7 +7,7 @@ import ( ) type TGeomPointInst struct { - handle + TGeomPoint } // TGeomPointInstFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tgeompointseq.go b/types/tgeompointseq.go index 08544b6..8a056ff 100644 --- a/types/tgeompointseq.go +++ b/types/tgeompointseq.go @@ -7,7 +7,7 @@ import ( ) type TGeomPointSeq struct { - handle + TGeomPoint } // TGeomPointSeqFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tgeompointseqset.go b/types/tgeompointseqset.go index b9017fb..dc8565e 100644 --- a/types/tgeompointseqset.go +++ b/types/tgeompointseqset.go @@ -7,7 +7,7 @@ import ( ) type TGeomPointSeqSet struct { - handle + TGeomPoint } // TGeomPointSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/th3indexinst.go b/types/th3indexinst.go index 5abaf92..41b495d 100644 --- a/types/th3indexinst.go +++ b/types/th3indexinst.go @@ -9,7 +9,7 @@ import ( ) type TH3IndexInst struct { - handle + TH3Index } // TH3IndexInstFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/th3indexseq.go b/types/th3indexseq.go index 42e28ca..6234248 100644 --- a/types/th3indexseq.go +++ b/types/th3indexseq.go @@ -9,7 +9,7 @@ import ( ) type TH3IndexSeq struct { - handle + TH3Index } // TH3IndexSeqFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/th3indexseqset.go b/types/th3indexseqset.go index 2a3e66e..22242f7 100644 --- a/types/th3indexseqset.go +++ b/types/th3indexseqset.go @@ -9,7 +9,7 @@ import ( ) type TH3IndexSeqSet struct { - handle + TH3Index } // TH3IndexSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tintinst.go b/types/tintinst.go index 4df7898..865ffaf 100644 --- a/types/tintinst.go +++ b/types/tintinst.go @@ -9,7 +9,7 @@ import ( ) type TIntInst struct { - handle + TInt } // TIntInstFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tintseq.go b/types/tintseq.go index dcf503c..25cd3c1 100644 --- a/types/tintseq.go +++ b/types/tintseq.go @@ -9,7 +9,7 @@ import ( ) type TIntSeq struct { - handle + TInt } // TIntSeqFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tintseqset.go b/types/tintseqset.go index 95e28ad..c0c41ea 100644 --- a/types/tintseqset.go +++ b/types/tintseqset.go @@ -9,7 +9,7 @@ import ( ) type TIntSeqSet struct { - handle + TInt } // TIntSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tjsonbinst.go b/types/tjsonbinst.go index 8323647..72942ac 100644 --- a/types/tjsonbinst.go +++ b/types/tjsonbinst.go @@ -9,7 +9,7 @@ import ( ) type TJsonbInst struct { - handle + TJsonb } // TJsonbInstFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tjsonbseq.go b/types/tjsonbseq.go index cbea172..367f42f 100644 --- a/types/tjsonbseq.go +++ b/types/tjsonbseq.go @@ -9,7 +9,7 @@ import ( ) type TJsonbSeq struct { - handle + TJsonb } // TJsonbSeqFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tjsonbseqset.go b/types/tjsonbseqset.go index e54b689..1a21644 100644 --- a/types/tjsonbseqset.go +++ b/types/tjsonbseqset.go @@ -9,7 +9,7 @@ import ( ) type TJsonbSeqSet struct { - handle + TJsonb } // TJsonbSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tnpoint.go b/types/tnpoint.go index 11039b7..44ed417 100644 --- a/types/tnpoint.go +++ b/types/tnpoint.go @@ -141,12 +141,12 @@ func (x *TNpoint) StartValue() (*Npoint, error) { } // Trajectory is MEOS tnpoint_trajectory. -func (x *TNpoint) Trajectory() (*TRGeometrySeqSet, error) { +func (x *TNpoint) Trajectory() (*Geo, error) { _r0, _err := functions.TnpointTrajectory(functions.TemporalFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // Value is MEOS tnpoint_value. @@ -201,16 +201,16 @@ func (x *TNpoint) Unnest(values unsafe.Pointer, count unsafe.Pointer) (unsafe.Po } // Twcentroid is MEOS tnpoint_twcentroid. -func (x *TNpoint) Twcentroid() (*TRGeometrySeqSet, error) { +func (x *TNpoint) Twcentroid() (*Geo, error) { _r0, _err := functions.TnpointTwcentroid(functions.TemporalFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // AtGeom is MEOS tnpoint_at_geom. -func (x *TNpoint) AtGeom(gs *TRGeometrySeqSet) (*Temporal, error) { +func (x *TNpoint) AtGeom(gs *Geo) (*Temporal, error) { _r0, _err := functions.TnpointAtGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) if _err != nil { return nil, _err @@ -246,7 +246,7 @@ func (x *TNpoint) AtStbox(box *STBox, border_inc bool) (*Temporal, error) { } // MinusGeom is MEOS tnpoint_minus_geom. -func (x *TNpoint) MinusGeom(gs *TRGeometrySeqSet) (*Temporal, error) { +func (x *TNpoint) MinusGeom(gs *Geo) (*Temporal, error) { _r0, _err := functions.TnpointMinusGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) if _err != nil { return nil, _err diff --git a/types/tnpointinst.go b/types/tnpointinst.go index dbe55ac..d29487a 100644 --- a/types/tnpointinst.go +++ b/types/tnpointinst.go @@ -9,7 +9,7 @@ import ( ) type TNpointInst struct { - handle + TNpoint } // TNpointInstFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tnpointseq.go b/types/tnpointseq.go index 69ef39a..01e8983 100644 --- a/types/tnpointseq.go +++ b/types/tnpointseq.go @@ -9,7 +9,7 @@ import ( ) type TNpointSeq struct { - handle + TNpoint } // TNpointSeqFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tnpointseqset.go b/types/tnpointseqset.go index a8478a9..bba5ca4 100644 --- a/types/tnpointseqset.go +++ b/types/tnpointseqset.go @@ -9,7 +9,7 @@ import ( ) type TNpointSeqSet struct { - handle + TNpoint } // TNpointSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tpcpatchinst.go b/types/tpcpatchinst.go index 4377945..7debd7e 100644 --- a/types/tpcpatchinst.go +++ b/types/tpcpatchinst.go @@ -9,7 +9,7 @@ import ( ) type TPcpatchInst struct { - handle + TPcpatch } // TPcpatchInstFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tpcpatchseq.go b/types/tpcpatchseq.go index 8ca1362..f7a7e24 100644 --- a/types/tpcpatchseq.go +++ b/types/tpcpatchseq.go @@ -9,7 +9,7 @@ import ( ) type TPcpatchSeq struct { - handle + TPcpatch } // TPcpatchSeqFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tpcpatchseqset.go b/types/tpcpatchseqset.go index 0d36e10..e801d05 100644 --- a/types/tpcpatchseqset.go +++ b/types/tpcpatchseqset.go @@ -9,7 +9,7 @@ import ( ) type TPcpatchSeqSet struct { - handle + TPcpatch } // TPcpatchSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tpcpointinst.go b/types/tpcpointinst.go index 3b071e2..8ae9410 100644 --- a/types/tpcpointinst.go +++ b/types/tpcpointinst.go @@ -9,7 +9,7 @@ import ( ) type TPcpointInst struct { - handle + TPcpoint } // TPcpointInstFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tpcpointseq.go b/types/tpcpointseq.go index 37899c5..297a352 100644 --- a/types/tpcpointseq.go +++ b/types/tpcpointseq.go @@ -9,7 +9,7 @@ import ( ) type TPcpointSeq struct { - handle + TPcpoint } // TPcpointSeqFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tpcpointseqset.go b/types/tpcpointseqset.go index 5b67516..71bf0d2 100644 --- a/types/tpcpointseqset.go +++ b/types/tpcpointseqset.go @@ -9,7 +9,7 @@ import ( ) type TPcpointSeqSet struct { - handle + TPcpoint } // TPcpointSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tpoint.go b/types/tpoint.go index c65f0a4..8091279 100644 --- a/types/tpoint.go +++ b/types/tpoint.go @@ -26,7 +26,7 @@ func TPointFromPointer(p unsafe.Pointer) *TPoint { } // TPointFromBaseTemp is MEOS tpoint_from_base_temp. -func TPointFromBaseTemp(gs *TRGeometrySeqSet, temp *Temporal) (*Temporal, error) { +func TPointFromBaseTemp(gs *Geo, temp *Temporal) (*Temporal, error) { _r0, _err := functions.TpointFromBaseTemp(functions.GeomFromPointer(gs.Pointer()), functions.TemporalFromPointer(temp.Pointer())) if _err != nil { return nil, _err @@ -44,7 +44,7 @@ func (x *TPoint) AsMvtgeom(bounds *STBox, extent int32, buffer int32, clip_geom } // TfloatToGeomeas is MEOS tpoint_tfloat_to_geomeas. -func (x *TPoint) TfloatToGeomeas(measure *Temporal, segmentize bool) (*TRGeometrySeqSet, bool, error) { +func (x *TPoint) TfloatToGeomeas(measure *Temporal, segmentize bool) (*Geo, bool, error) { _found, _value, _err := functions.TpointTfloatToGeomeas(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(measure.Pointer()), segmentize) if _err != nil { return nil, false, _err @@ -52,7 +52,7 @@ func (x *TPoint) TfloatToGeomeas(measure *Temporal, segmentize bool) (*TRGeometr if !_found { return nil, false, nil } - return TRGeometrySeqSetFromPointer(_value.Pointer()), true, nil + return GeoFromPointer(_value.Pointer()), true, nil } // AngularDifference is MEOS tpoint_angular_difference. @@ -149,21 +149,21 @@ func (x *TPoint) Speed(spheroid bool) (*Temporal, error) { } // Trajectory is MEOS tpoint_trajectory. -func (x *TPoint) Trajectory(unary_union bool) (*TRGeometrySeqSet, error) { +func (x *TPoint) Trajectory(unary_union bool) (*Geo, error) { _r0, _err := functions.TpointTrajectory(functions.TemporalFromPointer(x.Pointer()), unary_union) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // Twcentroid is MEOS tpoint_twcentroid. -func (x *TPoint) Twcentroid() (*TRGeometrySeqSet, error) { +func (x *TPoint) Twcentroid() (*Geo, error) { _r0, _err := functions.TpointTwcentroid(functions.TemporalFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // MakeSimple is MEOS tpoint_make_simple. @@ -185,7 +185,7 @@ func (x *TPoint) AtElevation(s *Span) (*Temporal, error) { } // AtGeom is MEOS tpoint_at_geom. -func (x *TPoint) AtGeom(gs *TRGeometrySeqSet) (*Temporal, error) { +func (x *TPoint) AtGeom(gs *Geo) (*Temporal, error) { _r0, _err := functions.TpointAtGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) if _err != nil { return nil, _err @@ -194,7 +194,7 @@ func (x *TPoint) AtGeom(gs *TRGeometrySeqSet) (*Temporal, error) { } // AtValue is MEOS tpoint_at_value. -func (x *TPoint) AtValue(gs *TRGeometrySeqSet) (*Temporal, error) { +func (x *TPoint) AtValue(gs *Geo) (*Temporal, error) { _r0, _err := functions.TpointAtValue(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) if _err != nil { return nil, _err @@ -212,7 +212,7 @@ func (x *TPoint) MinusElevation(s *Span) (*Temporal, error) { } // MinusGeom is MEOS tpoint_minus_geom. -func (x *TPoint) MinusGeom(gs *TRGeometrySeqSet) (*Temporal, error) { +func (x *TPoint) MinusGeom(gs *Geo) (*Temporal, error) { _r0, _err := functions.TpointMinusGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) if _err != nil { return nil, _err @@ -221,7 +221,7 @@ func (x *TPoint) MinusGeom(gs *TRGeometrySeqSet) (*Temporal, error) { } // MinusValue is MEOS tpoint_minus_value. -func (x *TPoint) MinusValue(gs *TRGeometrySeqSet) (*Temporal, error) { +func (x *TPoint) MinusValue(gs *Geo) (*Temporal, error) { _r0, _err := functions.TpointMinusValue(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) if _err != nil { return nil, _err diff --git a/types/tpose.go b/types/tpose.go index 8ded44a..08e2a1b 100644 --- a/types/tpose.go +++ b/types/tpose.go @@ -69,7 +69,7 @@ func (x *TPose) AsGeoposeStream(precision int) (string, error) { } // ApplyGeo is MEOS tpose_apply_geo. -func (x *TPose) ApplyGeo(body *TRGeometrySeqSet) (*Temporal, error) { +func (x *TPose) ApplyGeo(body *Geo) (*Temporal, error) { _r0, _err := functions.TposeApplyGeo(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(body.Pointer())) if _err != nil { return nil, _err @@ -267,12 +267,12 @@ func (x *TPose) StartValue() (*Pose, error) { } // Trajectory is MEOS tpose_trajectory. -func (x *TPose) Trajectory() (*TRGeometrySeqSet, error) { +func (x *TPose) Trajectory() (*Geo, error) { _r0, _err := functions.TposeTrajectory(functions.TemporalFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // Value is MEOS tpose_value. @@ -336,7 +336,7 @@ func (x *TPose) AtElevation(s *Span) (*Temporal, error) { } // AtGeom is MEOS tpose_at_geom. -func (x *TPose) AtGeom(gs *TRGeometrySeqSet) (*Temporal, error) { +func (x *TPose) AtGeom(gs *Geo) (*Temporal, error) { _r0, _err := functions.TposeAtGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) if _err != nil { return nil, _err @@ -372,7 +372,7 @@ func (x *TPose) MinusElevation(s *Span) (*Temporal, error) { } // MinusGeom is MEOS tpose_minus_geom. -func (x *TPose) MinusGeom(gs *TRGeometrySeqSet) (*Temporal, error) { +func (x *TPose) MinusGeom(gs *Geo) (*Temporal, error) { _r0, _err := functions.TposeMinusGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) if _err != nil { return nil, _err diff --git a/types/tposechaininst.go b/types/tposechaininst.go index d38a0b3..541120f 100644 --- a/types/tposechaininst.go +++ b/types/tposechaininst.go @@ -9,7 +9,7 @@ import ( ) type TPoseChainInst struct { - handle + TPoseChain } // TPoseChainInstFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tposechainseq.go b/types/tposechainseq.go index c739515..5c4b611 100644 --- a/types/tposechainseq.go +++ b/types/tposechainseq.go @@ -9,7 +9,7 @@ import ( ) type TPoseChainSeq struct { - handle + TPoseChain } // TPoseChainSeqFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tposechainseqset.go b/types/tposechainseqset.go index 1416c44..b773dfd 100644 --- a/types/tposechainseqset.go +++ b/types/tposechainseqset.go @@ -9,7 +9,7 @@ import ( ) type TPoseChainSeqSet struct { - handle + TPoseChain } // TPoseChainSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tposeinst.go b/types/tposeinst.go index ec3675a..274962e 100644 --- a/types/tposeinst.go +++ b/types/tposeinst.go @@ -9,7 +9,7 @@ import ( ) type TPoseInst struct { - handle + TPose } // TPoseInstFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tposeseq.go b/types/tposeseq.go index 257ad2b..905ca0f 100644 --- a/types/tposeseq.go +++ b/types/tposeseq.go @@ -9,7 +9,7 @@ import ( ) type TPoseSeq struct { - handle + TPose } // TPoseSeqFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tposeseqset.go b/types/tposeseqset.go index 0884325..37b8503 100644 --- a/types/tposeseqset.go +++ b/types/tposeseqset.go @@ -9,7 +9,7 @@ import ( ) type TPoseSeqSet struct { - handle + TPose } // TPoseSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tquadbininst.go b/types/tquadbininst.go index c59c21d..c603836 100644 --- a/types/tquadbininst.go +++ b/types/tquadbininst.go @@ -9,7 +9,7 @@ import ( ) type TQuadbinInst struct { - handle + TQuadbin } // TQuadbinInstFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tquadbinseq.go b/types/tquadbinseq.go index a5190e3..0c28272 100644 --- a/types/tquadbinseq.go +++ b/types/tquadbinseq.go @@ -9,7 +9,7 @@ import ( ) type TQuadbinSeq struct { - handle + TQuadbin } // TQuadbinSeqFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/tquadbinseqset.go b/types/tquadbinseqset.go index 6bf4130..18d2cab 100644 --- a/types/tquadbinseqset.go +++ b/types/tquadbinseqset.go @@ -9,7 +9,7 @@ import ( ) type TQuadbinSeqSet struct { - handle + TQuadbin } // TQuadbinSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/trgeometry.go b/types/trgeometry.go index cabe565..41b5da1 100644 --- a/types/trgeometry.go +++ b/types/trgeometry.go @@ -114,21 +114,21 @@ func (x *TRGeometry) EndSequence() (*Temporal, error) { } // EndValue is MEOS trgeometry_end_value. -func (x *TRGeometry) EndValue() (*TRGeometrySeqSet, error) { +func (x *TRGeometry) EndValue() (*Geo, error) { _r0, _err := functions.TrgeometryEndValue(functions.TemporalFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // Geom is MEOS trgeometry_geom. -func (x *TRGeometry) Geom() (*TRGeometrySeqSet, error) { +func (x *TRGeometry) Geom() (*Geo, error) { _r0, _err := functions.TrgeometryGeom(functions.TemporalFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // InstantN is MEOS trgeometry_instant_n. @@ -231,12 +231,12 @@ func (x *TRGeometry) StartSequence() (*Temporal, error) { } // StartValue is MEOS trgeometry_start_value. -func (x *TRGeometry) StartValue() (*TRGeometrySeqSet, error) { +func (x *TRGeometry) StartValue() (*Geo, error) { _r0, _err := functions.TrgeometryStartValue(functions.TemporalFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // Value is MEOS trgeometry_value. @@ -267,7 +267,7 @@ func (x *TRGeometry) Unnest(values unsafe.Pointer, count unsafe.Pointer) (unsafe } // ValueN is MEOS trgeometry_value_n. -func (x *TRGeometry) ValueN(n int) (*TRGeometrySeqSet, bool, error) { +func (x *TRGeometry) ValueN(n int) (*Geo, bool, error) { _found, _value, _err := functions.TrgeometryValueN(functions.TemporalFromPointer(x.Pointer()), n) if _err != nil { return nil, false, _err @@ -275,11 +275,11 @@ func (x *TRGeometry) ValueN(n int) (*TRGeometrySeqSet, bool, error) { if !_found { return nil, false, nil } - return TRGeometrySeqSetFromPointer(_value.Pointer()), true, nil + return GeoFromPointer(_value.Pointer()), true, nil } // ValueAtTimestamptz is MEOS trgeometry_value_at_timestamptz. -func (x *TRGeometry) ValueAtTimestamptz(t int64, strict bool) (*TRGeometrySeqSet, bool, error) { +func (x *TRGeometry) ValueAtTimestamptz(t int64, strict bool) (*Geo, bool, error) { _found, _value, _err := functions.TrgeometryValueAtTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, strict) if _err != nil { return nil, false, _err @@ -287,16 +287,16 @@ func (x *TRGeometry) ValueAtTimestamptz(t int64, strict bool) (*TRGeometrySeqSet if !_found { return nil, false, nil } - return TRGeometrySeqSetFromPointer(_value.Pointer()), true, nil + return GeoFromPointer(_value.Pointer()), true, nil } // TraversedArea is MEOS trgeometry_traversed_area. -func (x *TRGeometry) TraversedArea(unary_union bool) (*TRGeometrySeqSet, error) { +func (x *TRGeometry) TraversedArea(unary_union bool) (*Geo, error) { _r0, _err := functions.TrgeometryTraversedArea(functions.TemporalFromPointer(x.Pointer()), unary_union) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // Centroid is MEOS trgeometry_centroid. @@ -309,16 +309,16 @@ func (x *TRGeometry) Centroid() (*Temporal, error) { } // ConvexHull is MEOS trgeometry_convex_hull. -func (x *TRGeometry) ConvexHull() (*TRGeometrySeqSet, error) { +func (x *TRGeometry) ConvexHull() (*Geo, error) { _r0, _err := functions.TrgeometryConvexHull(functions.TemporalFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // BodyPointTrajectory is MEOS trgeometry_body_point_trajectory. -func (x *TRGeometry) BodyPointTrajectory(gs *TRGeometrySeqSet) (*Temporal, error) { +func (x *TRGeometry) BodyPointTrajectory(gs *Geo) (*Temporal, error) { _r0, _err := functions.TrgeometryBodyPointTrajectory(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) if _err != nil { return nil, _err @@ -327,7 +327,7 @@ func (x *TRGeometry) BodyPointTrajectory(gs *TRGeometrySeqSet) (*Temporal, error } // SpaceBoxes is MEOS trgeometry_space_boxes. -func (x *TRGeometry) SpaceBoxes(xsize float64, ysize float64, zsize float64, sorigin *TRGeometrySeqSet, bitmatrix bool, border_inc bool, count unsafe.Pointer) (*STBox, error) { +func (x *TRGeometry) SpaceBoxes(xsize float64, ysize float64, zsize float64, sorigin *Geo, bitmatrix bool, border_inc bool, count unsafe.Pointer) (*STBox, error) { _r0, _err := functions.TrgeometrySpaceBoxes(functions.TemporalFromPointer(x.Pointer()), xsize, ysize, zsize, functions.GeomFromPointer(sorigin.Pointer()), bitmatrix, border_inc, count) if _err != nil { return nil, _err @@ -399,12 +399,12 @@ func (x *TRGeometry) Speed() (*Temporal, error) { } // Twcentroid is MEOS trgeometry_twcentroid. -func (x *TRGeometry) Twcentroid() (*TRGeometrySeqSet, error) { +func (x *TRGeometry) Twcentroid() (*Geo, error) { _r0, _err := functions.TrgeometryTwcentroid(functions.TemporalFromPointer(x.Pointer())) if _err != nil { return nil, _err } - return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil + return GeoFromPointer(_r0.Pointer()), nil } // AppendTsequence is MEOS trgeometry_append_tsequence. @@ -579,7 +579,7 @@ func (x *TRGeometry) BeforeTimestamptz(t int64, strict bool) (*Temporal, error) } // AtGeom is MEOS trgeometry_at_geom. -func (x *TRGeometry) AtGeom(gs *TRGeometrySeqSet) (*Temporal, error) { +func (x *TRGeometry) AtGeom(gs *Geo) (*Temporal, error) { _r0, _err := functions.TrgeometryAtGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) if _err != nil { return nil, _err @@ -588,7 +588,7 @@ func (x *TRGeometry) AtGeom(gs *TRGeometrySeqSet) (*Temporal, error) { } // MinusGeom is MEOS trgeometry_minus_geom. -func (x *TRGeometry) MinusGeom(gs *TRGeometrySeqSet) (*Temporal, error) { +func (x *TRGeometry) MinusGeom(gs *Geo) (*Temporal, error) { _r0, _err := functions.TrgeometryMinusGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) if _err != nil { return nil, _err diff --git a/types/trgeometryinst.go b/types/trgeometryinst.go index 3af8965..62d1c1f 100644 --- a/types/trgeometryinst.go +++ b/types/trgeometryinst.go @@ -9,7 +9,7 @@ import ( ) type TRGeometryInst struct { - handle + TRGeometry } // TRGeometryInstFromPointer wraps a MEOS pointer, answering nil for nil so an @@ -24,7 +24,7 @@ func TRGeometryInstFromPointer(p unsafe.Pointer) *TRGeometryInst { } // TRGeometryInstMake is MEOS trgeometryinst_make. -func TRGeometryInstMake(geom *TRGeometrySeqSet, pose *Pose, t int64) (*Temporal, error) { +func TRGeometryInstMake(geom *Geo, pose *Pose, t int64) (*Temporal, error) { _r0, _err := functions.TrgeometryinstMake(functions.GeomFromPointer(geom.Pointer()), functions.PoseFromPointer(pose.Pointer()), t) if _err != nil { return nil, _err diff --git a/types/trgeometryseq.go b/types/trgeometryseq.go index 5ad2c22..a63edc1 100644 --- a/types/trgeometryseq.go +++ b/types/trgeometryseq.go @@ -9,7 +9,7 @@ import ( ) type TRGeometrySeq struct { - handle + TRGeometry } // TRGeometrySeqFromPointer wraps a MEOS pointer, answering nil for nil so an @@ -24,7 +24,7 @@ func TRGeometrySeqFromPointer(p unsafe.Pointer) *TRGeometrySeq { } // TRGeometrySeqMake is MEOS trgeometryseq_make. -func TRGeometrySeqMake(geom *TRGeometrySeqSet, instants unsafe.Pointer, count int, lower_inc bool, upper_inc bool, interp functions.Interpolation, normalize bool) (*Temporal, error) { +func TRGeometrySeqMake(geom *Geo, instants unsafe.Pointer, count int, lower_inc bool, upper_inc bool, interp functions.Interpolation, normalize bool) (*Temporal, error) { _r0, _err := functions.TrgeometryseqMake(functions.GeomFromPointer(geom.Pointer()), instants, count, lower_inc, upper_inc, interp, normalize) if _err != nil { return nil, _err diff --git a/types/trgeometryseqset.go b/types/trgeometryseqset.go index 62a8870..446a4e7 100644 --- a/types/trgeometryseqset.go +++ b/types/trgeometryseqset.go @@ -9,7 +9,7 @@ import ( ) type TRGeometrySeqSet struct { - handle + TRGeometry } // TRGeometrySeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an @@ -23,9 +23,9 @@ func TRGeometrySeqSetFromPointer(p unsafe.Pointer) *TRGeometrySeqSet { return v } -// Make is MEOS trgeometryseqset_make. -func (x *TRGeometrySeqSet) Make(sequences unsafe.Pointer, count int, normalize bool) (*Temporal, error) { - _r0, _err := functions.TrgeometryseqsetMake(functions.GeomFromPointer(x.Pointer()), sequences, count, normalize) +// TRGeometrySeqSetMake is MEOS trgeometryseqset_make. +func TRGeometrySeqSetMake(geom *Geo, sequences unsafe.Pointer, count int, normalize bool) (*Temporal, error) { + _r0, _err := functions.TrgeometryseqsetMake(functions.GeomFromPointer(geom.Pointer()), sequences, count, normalize) if _err != nil { return nil, _err } diff --git a/types/ts2cellinst.go b/types/ts2cellinst.go index 463786d..ee9f19a 100644 --- a/types/ts2cellinst.go +++ b/types/ts2cellinst.go @@ -9,7 +9,7 @@ import ( ) type TS2CellInst struct { - handle + TS2Cell } // TS2CellInstFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/ts2cellseq.go b/types/ts2cellseq.go index 883f0e3..72cc148 100644 --- a/types/ts2cellseq.go +++ b/types/ts2cellseq.go @@ -9,7 +9,7 @@ import ( ) type TS2CellSeq struct { - handle + TS2Cell } // TS2CellSeqFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/ts2cellseqset.go b/types/ts2cellseqset.go index 52328de..0e19a9e 100644 --- a/types/ts2cellseqset.go +++ b/types/ts2cellseqset.go @@ -9,7 +9,7 @@ import ( ) type TS2CellSeqSet struct { - handle + TS2Cell } // TS2CellSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/ttextinst.go b/types/ttextinst.go index c51aacd..a5aa5c5 100644 --- a/types/ttextinst.go +++ b/types/ttextinst.go @@ -9,7 +9,7 @@ import ( ) type TTextInst struct { - handle + TText } // TTextInstFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/ttextseq.go b/types/ttextseq.go index 810fa58..125f65a 100644 --- a/types/ttextseq.go +++ b/types/ttextseq.go @@ -9,7 +9,7 @@ import ( ) type TTextSeq struct { - handle + TText } // TTextSeqFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/ttextseqset.go b/types/ttextseqset.go index 7ddb239..fc95fe3 100644 --- a/types/ttextseqset.go +++ b/types/ttextseqset.go @@ -9,7 +9,7 @@ import ( ) type TTextSeqSet struct { - handle + TText } // TTextSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an