From fab7276f08bea08d3acda2ae93ae1a895f63f38b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Esteban=20Zim=C3=A1nyi?= Date: Sun, 1 Nov 2026 19:43:24 +0100 Subject: [PATCH] Read and write the binary formats as byte slices A generated type writes its WKB and EWKB as a []byte and reads them from one, the length carried by the slice, as the catalog's shape states the buffer: a size_t * the shape lists in outParams is the length of the buffer the call answers, so it leaves the signature, and a uint8_t array it lists in inputArrays is taken as a []byte whose length fills the parameter the shape names. Temporal.AsWKB(variant) answers a []byte, TemporalFromWKB(wkb []byte) and TGeomPointFromEWKB(wkb []byte) read one, and the hex writers, AsHexWKB and AsHexEWKB, answer their string with no size to pass. The flat layer's TakeBytes copies the buffer MEOS answers into Go memory and frees MEOS's, as every wrapper answering a char * frees it once C.GoString has copied it: 149 methods take the forms, 134 of them a []byte. Examples are named Example_ where the identifier they show is the generated package's, as go vet reads an example's name. Measured: the 128 root examples pass under TZ=UTC, a temporal point written as EWKB and read back from the bytes writing the same bytes; the functions, types and root packages build with no go vet finding, and the parity tests pass. --- example_pointer_boundary_test.go | 2 +- example_types_io_test.go | 19 ++++++++++---- functions/cgo.go | 19 +++++++++++++- tools/codegen.py | 19 +++++++++++++- tools/objectgen.py | 44 +++++++++++++++++++++++++++++++- types/bigintset.go | 4 +-- types/bigintspan.go | 4 +-- types/bigintspanset.go | 4 +-- types/cbuffer.go | 36 ++++++++++++++++---------- types/cbufferset.go | 8 +++--- types/dateset.go | 4 +-- types/datespan.go | 4 +-- types/datespanset.go | 4 +-- types/floatset.go | 4 +-- types/floatspan.go | 4 +-- types/floatspanset.go | 4 +-- types/geo.go | 15 +++++++---- types/geography.go | 4 +-- types/geogset.go | 8 +++--- types/geometry.go | 4 +-- types/geomset.go | 8 +++--- types/h3indexset.go | 8 +++--- types/intset.go | 4 +-- types/intspan.go | 4 +-- types/intspanset.go | 4 +-- types/jsonbset.go | 4 +-- types/npoint.go | 36 ++++++++++++++++---------- types/npointset.go | 8 +++--- types/nsegment.go | 36 ++++++++++++++++---------- types/pcpatchset.go | 8 +++--- types/pcpointset.go | 8 +++--- types/pose.go | 36 ++++++++++++++++---------- types/posechain.go | 36 ++++++++++++++++---------- types/posechainset.go | 8 +++--- types/poseset.go | 8 +++--- types/quadbinset.go | 8 +++--- types/raquet.go | 43 +++++++++++++++++++++---------- types/raster.go | 43 +++++++++++++++++++++---------- types/s2cellset.go | 8 +++--- types/set.go | 27 ++++++++++++-------- types/span.go | 27 ++++++++++++-------- types/spanset.go | 27 ++++++++++++-------- types/spatialset.go | 12 +++++---- types/stbox.go | 43 +++++++++++++++++++------------ types/tbigint.go | 4 +-- types/tbool.go | 4 +-- types/tbox.go | 27 ++++++++++++-------- types/tcbuffer.go | 8 +++--- types/temporal.go | 27 ++++++++++++-------- types/textset.go | 4 +-- types/tfloat.go | 4 +-- types/tgeogpoint.go | 8 +++--- types/tgeography.go | 8 +++--- types/tgeometry.go | 8 +++--- types/tgeompoint.go | 8 +++--- types/th3index.go | 8 +++--- types/tint.go | 4 +-- types/tjsonb.go | 4 +-- types/tnpoint.go | 8 +++--- types/tpcbox.go | 43 +++++++++++++++++++------------ types/tpcpatch.go | 8 +++--- types/tpcpoint.go | 8 +++--- types/tpose.go | 8 +++--- types/tposechain.go | 8 +++--- types/tquadbin.go | 8 +++--- types/trgeometry.go | 8 +++--- types/ts2cell.go | 8 +++--- types/tspatial.go | 12 +++++---- types/tstzset.go | 4 +-- types/tstzspan.go | 4 +-- types/tstzspanset.go | 4 +-- types/ttext.go | 4 +-- 72 files changed, 573 insertions(+), 356 deletions(-) diff --git a/example_pointer_boundary_test.go b/example_pointer_boundary_test.go index a920f4e..c15e0ff 100644 --- a/example_pointer_boundary_test.go +++ b/example_pointer_boundary_test.go @@ -27,7 +27,7 @@ func ExampleTemporalFromPointer() { // 3 Sequence } -func ExampleTemporal_Pointer() { +func Example_temporalPointer() { tb := NewTBoolSeq("{FALSE@2022-10-01, TRUE@2022-10-03}") crossed := functions.TemporalFromPointer(unsafe.Pointer(tb.Inner())) diff --git a/example_types_io_test.go b/example_types_io_test.go index 905b846..5cfcd4c 100644 --- a/example_types_io_test.go +++ b/example_types_io_test.go @@ -7,8 +7,8 @@ package gomeos // example_pointer_boundary_test.go does, through the pointer both share. import ( + "bytes" "fmt" - "unsafe" "github.com/MobilityDB/GoMEOS/types" ) @@ -30,24 +30,33 @@ func ExampleTGeomPointFromEWKT() { func ExampleTGeomPointFromHexEWKB() { point, _ := types.TGeomPointFromEWKT("SRID=4326;Point(1 1)@2024-12-06") - var size uint64 // the size_t the writer states the length in - hex, _ := point.AsHexEWKB(0, unsafe.Pointer(&size)) + hex, _ := point.AsHexEWKB(0) read, err := types.TGeomPointFromHexEWKB(hex) fmt.Println(read, err) // Output: // POINT(1 1)@2024-12-06 00:00:00+00 } -func ExampleCbuffer_String() { +func Example_cbufferString() { cbuffer, _ := types.CbufferFromText("Cbuffer(Point(1 1),0.5)") fmt.Println(cbuffer) // Output: // Cbuffer(POINT(1 1),0.5) } -func ExampleFloatSpan_String() { +func Example_floatSpanString() { span, _ := types.FloatSpanFromText("[8, 10]") fmt.Println(span) // Output: // [8, 10] } + +func Example_temporalEWKB() { + point, _ := types.TGeomPointFromEWKT("SRID=4326;Point(1 1)@2024-12-06") + wkb, err := point.AsEWKB(0) + read, _ := types.TGeomPointFromEWKB(wkb) + again, _ := read.AsEWKB(0) + fmt.Println(len(wkb) > 0, err, bytes.Equal(wkb, again), read) + // Output: + // true true POINT(1 1)@2024-12-06 00:00:00+00 +} diff --git a/functions/cgo.go b/functions/cgo.go index 120ca4a..0be384a 100644 --- a/functions/cgo.go +++ b/functions/cgo.go @@ -22,6 +22,7 @@ package functions #cgo linux CFLAGS: -I/usr/include/h3 #include +#include #include "meos.h" #include "meos_catalog.h" #include "meos_cbuffer.h" @@ -50,7 +51,23 @@ package functions */ import "C" -import "fmt" +import ( + "fmt" + "unsafe" +) + +// TakeBytes copies the n bytes a MEOS writer answered at p into Go memory and +// frees MEOS's buffer, as every wrapper answering a char * frees it once +// C.GoString has copied it (#_free_returned_string): the byte buffer of a WKB +// writer, whose length MEOS states through its size_t * out-parameter, becomes +// a []byte the caller owns. A nil buffer answers nil. +func TakeBytes(p unsafe.Pointer, n uint64) []byte { + if p == nil { + return nil + } + defer C.free(p) + return C.GoBytes(p, C.int(n)) +} // MeosError reports that the MEOS call behind a wrapper failed, carrying the // error code MEOS recorded for it. diff --git a/tools/codegen.py b/tools/codegen.py index d1c0d31..34ba6a9 100644 --- a/tools/codegen.py +++ b/tools/codegen.py @@ -1166,11 +1166,28 @@ def _todo_stub(c_name: str, reason: str) -> str: #cgo linux CFLAGS: -I/usr/include/h3 #include +#include @INCLUDES@ */ import "C" -import "fmt" +import ( + "fmt" + "unsafe" +) + +// TakeBytes copies the n bytes a MEOS writer answered at p into Go memory and +// frees MEOS's buffer, as every wrapper answering a char * frees it once +// C.GoString has copied it (#_free_returned_string): the byte buffer of a WKB +// writer, whose length MEOS states through its size_t * out-parameter, becomes +// a []byte the caller owns. A nil buffer answers nil. +func TakeBytes(p unsafe.Pointer, n uint64) []byte { + if p == nil { + return nil + } + defer C.free(p) + return C.GoBytes(p, C.int(n)) +} // MeosError reports that the MEOS call behind a wrapper failed, carrying the // error code MEOS recorded for it. diff --git a/tools/objectgen.py b/tools/objectgen.py index 359cf00..4e74fb6 100644 --- a/tools/objectgen.py +++ b/tools/objectgen.py @@ -308,8 +308,42 @@ def method_for(self, cls: str, entry: dict) -> str | None: if params and self.class_of_handle(params[0][1]) in family: recv = params.pop(0) + # A byte buffer travels as a []byte, as MEOS.NET's method_for reads the + # catalog's shape: a `size_t *` the shape lists in `outParams` states the + # length of the buffer the call answers, so it leaves the signature and + # the buffer comes back as a []byte (functions.TakeBytes); a `uint8_t` + # array the shape lists in `inputArrays` is taken as a []byte, the + # parameter its length comes from filled with len(). + shape = f.get("shape") or {} + length_out = next( + (codegen._go_param_name(p["name"]) for p in f.get("params", []) + if p["name"] in (shape.get("outParams") or []) + and p["cType"].replace(" ", "") == "size_t*"), None) + byte_inputs = { + codegen._go_param_name(a["param"]): codegen._go_param_name(a["lengthFrom"]["name"]) + for a in shape.get("inputArrays") or [] + if (a.get("element") or {}).get("c") == "uint8_t" + and (a.get("lengthFrom") or {}).get("kind") == "param"} + length_of = {length: arr for arr, length in byte_inputs.items()} + prelude = [] + args, decl = [], [] for pname, ptype in params: + if pname == length_out: + prelude.append("\tvar _size uint64") + args.append("unsafe.Pointer(&_size)") + continue + if pname in byte_inputs: + local = f"_p_{pname}" + prelude.append(f"\tvar {local} unsafe.Pointer\n" + f"\tif len({ident(pname)}) > 0 {{\n" + f"\t\t{local} = unsafe.Pointer(&{ident(pname)}[0])\n\t}}") + decl.append(f"{ident(pname)} []byte") + args.append(local) + continue + if pname in length_of: + args.append(f"{self.qualify(ptype)}(len({ident(length_of[pname])}))") + continue mapped = self.map_param(ptype, ident(pname)) if mapped is None: self.deferred[cls].append(f"{oo}: parameter {pname} is {ptype}") @@ -341,11 +375,19 @@ def method_for(self, cls: str, entry: dict) -> str | None: folded = (len(sig.returns) == 2 and sig.returns[0] == "bool" and f["returnType"]["c"].replace("const ", "").strip() == "bool") - rets, body = [], [] + rets, body = [], list(prelude) call = f"functions.{sig.go_name}({', '.join(args)})" + answers_bytes = (length_out is not None and sig.returns == ["unsafe.Pointer"] + and f["returnType"]["c"].replace("const ", "").replace(" ", "") + == "uint8_t*") if not sig.returns: body.append(f"\treturn {call}") + elif answers_bytes: + rets = ["[]byte"] + body.append(f"\t_r0, _err := {call}") + body.append("\tif _err != nil {\n\t\treturn nil, _err\n\t}") + body.append("\treturn functions.TakeBytes(_r0, _size), nil") elif folded: mapped = self.map_return(sig.returns[1], "_value") if mapped is None: diff --git a/types/bigintset.go b/types/bigintset.go index 062e50f..4e53774 100644 --- a/types/bigintset.go +++ b/types/bigintset.go @@ -122,8 +122,8 @@ func BigIntSetFromText(str string) (*BigIntSet, error) { } // BigIntSetFromWKB is the portable fromWKB of MEOS set_from_wkb. -func BigIntSetFromWKB(wkb unsafe.Pointer, size uint) (*BigIntSet, error) { - r, err := SetFromWKB(wkb, size) +func BigIntSetFromWKB(wkb []byte) (*BigIntSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/bigintspan.go b/types/bigintspan.go index 230a001..8892102 100644 --- a/types/bigintspan.go +++ b/types/bigintspan.go @@ -155,8 +155,8 @@ func BigIntSpanFromText(str string) (*BigIntSpan, error) { } // BigIntSpanFromWKB is the portable fromWKB of MEOS span_from_wkb. -func BigIntSpanFromWKB(wkb unsafe.Pointer, size uint) (*BigIntSpan, error) { - r, err := SpanFromWKB(wkb, size) +func BigIntSpanFromWKB(wkb []byte) (*BigIntSpan, error) { + r, err := SpanFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/bigintspanset.go b/types/bigintspanset.go index 605d571..ebba0d4 100644 --- a/types/bigintspanset.go +++ b/types/bigintspanset.go @@ -110,8 +110,8 @@ func BigIntSpanSetFromText(str string) (*BigIntSpanSet, error) { } // BigIntSpanSetFromWKB is the portable fromWKB of MEOS spanset_from_wkb. -func BigIntSpanSetFromWKB(wkb unsafe.Pointer, size uint) (*BigIntSpanSet, error) { - r, err := SpanSetFromWKB(wkb, size) +func BigIntSpanSetFromWKB(wkb []byte) (*BigIntSpanSet, error) { + r, err := SpanSetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/cbuffer.go b/types/cbuffer.go index 4f1e1bc..cd85b1f 100644 --- a/types/cbuffer.go +++ b/types/cbuffer.go @@ -24,12 +24,13 @@ func CbufferFromPointer(p unsafe.Pointer) *Cbuffer { } // AsEWKB is MEOS cbuffer_as_ewkb. -func (x *Cbuffer) AsEWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.CbufferAsEWKB(functions.CbufferFromPointer(x.Pointer()), variant, size_out) +func (x *Cbuffer) AsEWKB(variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.CbufferAsEWKB(functions.CbufferFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // AsEWKT is MEOS cbuffer_as_ewkt. @@ -42,8 +43,9 @@ func (x *Cbuffer) AsEWKT(maxdd int) (string, error) { } // AsHexEWKB is MEOS cbuffer_as_hexewkb. -func (x *Cbuffer) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.CbufferAsHexewkb(functions.CbufferFromPointer(x.Pointer()), variant, size_out) +func (x *Cbuffer) AsHexEWKB(variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.CbufferAsHexewkb(functions.CbufferFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } @@ -51,8 +53,9 @@ func (x *Cbuffer) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, err } // AsHexWKB is MEOS cbuffer_as_hexwkb. -func (x *Cbuffer) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.CbufferAsHexwkb(functions.CbufferFromPointer(x.Pointer()), variant, size_out) +func (x *Cbuffer) AsHexWKB(variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.CbufferAsHexwkb(functions.CbufferFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } @@ -69,12 +72,13 @@ func (x *Cbuffer) AsText(maxdd int) (string, error) { } // AsWKB is MEOS cbuffer_as_wkb. -func (x *Cbuffer) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.CbufferAsWKB(functions.CbufferFromPointer(x.Pointer()), variant, size_out) +func (x *Cbuffer) AsWKB(variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.CbufferAsWKB(functions.CbufferFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // CbufferFromHexWKB is MEOS cbuffer_from_hexwkb. @@ -87,8 +91,12 @@ func CbufferFromHexWKB(hexwkb string) (*Cbuffer, error) { } // CbufferFromWKB is MEOS cbuffer_from_wkb. -func CbufferFromWKB(wkb unsafe.Pointer, size uint) (*Cbuffer, error) { - _r0, _err := functions.CbufferFromWKB(wkb, size) +func CbufferFromWKB(wkb []byte) (*Cbuffer, error) { + var _p_wkb unsafe.Pointer + if len(wkb) > 0 { + _p_wkb = unsafe.Pointer(&wkb[0]) + } + _r0, _err := functions.CbufferFromWKB(_p_wkb, uint(len(wkb))) if _err != nil { return nil, _err } @@ -330,8 +338,8 @@ func (x *Cbuffer) ToSet() (*Set, error) { } // CbufferFromEWKB is the portable fromEWKB of MEOS cbuffer_from_wkb. -func CbufferFromEWKB(wkb unsafe.Pointer, size uint) (*Cbuffer, error) { - return CbufferFromWKB(wkb, size) +func CbufferFromEWKB(wkb []byte) (*Cbuffer, error) { + return CbufferFromWKB(wkb) } // CbufferFromEWKT is the portable fromEWKT of MEOS cbuffer_in. diff --git a/types/cbufferset.go b/types/cbufferset.go index 727dab4..da464fe 100644 --- a/types/cbufferset.go +++ b/types/cbufferset.go @@ -90,8 +90,8 @@ func (x *CbufferSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { } // CbufferSetFromEWKB is the portable fromEWKB of MEOS set_from_wkb. -func CbufferSetFromEWKB(wkb unsafe.Pointer, size uint) (*CbufferSet, error) { - r, err := SetFromWKB(wkb, size) +func CbufferSetFromEWKB(wkb []byte) (*CbufferSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -135,8 +135,8 @@ func CbufferSetFromText(str string) (*CbufferSet, error) { } // CbufferSetFromWKB is the portable fromWKB of MEOS set_from_wkb. -func CbufferSetFromWKB(wkb unsafe.Pointer, size uint) (*CbufferSet, error) { - r, err := SetFromWKB(wkb, size) +func CbufferSetFromWKB(wkb []byte) (*CbufferSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/dateset.go b/types/dateset.go index cce1e70..974516d 100644 --- a/types/dateset.go +++ b/types/dateset.go @@ -131,8 +131,8 @@ func DateSetFromText(str string) (*DateSet, error) { } // DateSetFromWKB is the portable fromWKB of MEOS set_from_wkb. -func DateSetFromWKB(wkb unsafe.Pointer, size uint) (*DateSet, error) { - r, err := SetFromWKB(wkb, size) +func DateSetFromWKB(wkb []byte) (*DateSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/datespan.go b/types/datespan.go index 10cbb01..6dcb8a2 100644 --- a/types/datespan.go +++ b/types/datespan.go @@ -110,8 +110,8 @@ func DateSpanFromText(str string) (*DateSpan, error) { } // DateSpanFromWKB is the portable fromWKB of MEOS span_from_wkb. -func DateSpanFromWKB(wkb unsafe.Pointer, size uint) (*DateSpan, error) { - r, err := SpanFromWKB(wkb, size) +func DateSpanFromWKB(wkb []byte) (*DateSpan, error) { + r, err := SpanFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/datespanset.go b/types/datespanset.go index f690349..5b9db4f 100644 --- a/types/datespanset.go +++ b/types/datespanset.go @@ -149,8 +149,8 @@ func DateSpanSetFromText(str string) (*DateSpanSet, error) { } // DateSpanSetFromWKB is the portable fromWKB of MEOS spanset_from_wkb. -func DateSpanSetFromWKB(wkb unsafe.Pointer, size uint) (*DateSpanSet, error) { - r, err := SpanSetFromWKB(wkb, size) +func DateSpanSetFromWKB(wkb []byte) (*DateSpanSet, error) { + r, err := SpanSetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/floatset.go b/types/floatset.go index 2f4153a..fac4ee6 100644 --- a/types/floatset.go +++ b/types/floatset.go @@ -167,8 +167,8 @@ func FloatSetFromText(str string) (*FloatSet, error) { } // FloatSetFromWKB is the portable fromWKB of MEOS set_from_wkb. -func FloatSetFromWKB(wkb unsafe.Pointer, size uint) (*FloatSet, error) { - r, err := SetFromWKB(wkb, size) +func FloatSetFromWKB(wkb []byte) (*FloatSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/floatspan.go b/types/floatspan.go index 4d8f566..197c942 100644 --- a/types/floatspan.go +++ b/types/floatspan.go @@ -200,8 +200,8 @@ func FloatSpanFromText(str string) (*FloatSpan, error) { } // FloatSpanFromWKB is the portable fromWKB of MEOS span_from_wkb. -func FloatSpanFromWKB(wkb unsafe.Pointer, size uint) (*FloatSpan, error) { - r, err := SpanFromWKB(wkb, size) +func FloatSpanFromWKB(wkb []byte) (*FloatSpan, error) { + r, err := SpanFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/floatspanset.go b/types/floatspanset.go index 2202221..6eac627 100644 --- a/types/floatspanset.go +++ b/types/floatspanset.go @@ -164,8 +164,8 @@ func FloatSpanSetFromText(str string) (*FloatSpanSet, error) { } // FloatSpanSetFromWKB is the portable fromWKB of MEOS spanset_from_wkb. -func FloatSpanSetFromWKB(wkb unsafe.Pointer, size uint) (*FloatSpanSet, error) { - r, err := SpanSetFromWKB(wkb, size) +func FloatSpanSetFromWKB(wkb []byte) (*FloatSpanSet, error) { + r, err := SpanSetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/geo.go b/types/geo.go index 3c29aae..9fc2426 100644 --- a/types/geo.go +++ b/types/geo.go @@ -24,12 +24,13 @@ func GeoFromPointer(p unsafe.Pointer) *Geo { } // GeoAsEWKB is MEOS geo_as_ewkb. -func GeoAsEWKB(gs *TRGeometrySeqSet, endian *string, size unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.GeoAsEWKB(functions.GeomFromPointer(gs.Pointer()), endian, size) +func GeoAsEWKB(gs *TRGeometrySeqSet, endian *string) ([]byte, error) { + var _size uint64 + _r0, _err := functions.GeoAsEWKB(functions.GeomFromPointer(gs.Pointer()), endian, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // GeoAsEWKT is MEOS geo_as_ewkt. @@ -69,8 +70,12 @@ func GeoAsText(gs *TRGeometrySeqSet, precision int) (string, error) { } // GeoFromEWKB is MEOS geo_from_ewkb. -func GeoFromEWKB(wkb unsafe.Pointer, wkb_size uint, srid int32) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoFromEWKB(wkb, wkb_size, srid) +func GeoFromEWKB(wkb []byte, srid int32) (*TRGeometrySeqSet, error) { + var _p_wkb unsafe.Pointer + if len(wkb) > 0 { + _p_wkb = unsafe.Pointer(&wkb[0]) + } + _r0, _err := functions.GeoFromEWKB(_p_wkb, uint(len(wkb)), srid) if _err != nil { return nil, _err } diff --git a/types/geography.go b/types/geography.go index d16a645..28c39a5 100644 --- a/types/geography.go +++ b/types/geography.go @@ -141,8 +141,8 @@ func GeographyShortestline(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet, use_sph } // GeographyFromEWKB is the portable fromEWKB of MEOS geo_from_ewkb. -func GeographyFromEWKB(wkb unsafe.Pointer, wkb_size uint, srid int32) (*TRGeometrySeqSet, error) { - return GeoFromEWKB(wkb, wkb_size, srid) +func GeographyFromEWKB(wkb []byte, srid int32) (*TRGeometrySeqSet, error) { + return GeoFromEWKB(wkb, srid) } // GeographyFromMFJSON is the portable fromMFJSON of MEOS geo_from_geojson. diff --git a/types/geogset.go b/types/geogset.go index 804a7ca..f8b0755 100644 --- a/types/geogset.go +++ b/types/geogset.go @@ -33,8 +33,8 @@ func GeogSetIn(str string) (*Set, error) { } // GeogSetFromEWKB is the portable fromEWKB of MEOS set_from_wkb. -func GeogSetFromEWKB(wkb unsafe.Pointer, size uint) (*GeogSet, error) { - r, err := SetFromWKB(wkb, size) +func GeogSetFromEWKB(wkb []byte) (*GeogSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -78,8 +78,8 @@ func GeogSetFromText(str string) (*GeogSet, error) { } // GeogSetFromWKB is the portable fromWKB of MEOS set_from_wkb. -func GeogSetFromWKB(wkb unsafe.Pointer, size uint) (*GeogSet, error) { - r, err := SetFromWKB(wkb, size) +func GeogSetFromWKB(wkb []byte) (*GeogSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/geometry.go b/types/geometry.go index d29f1e0..28f826d 100644 --- a/types/geometry.go +++ b/types/geometry.go @@ -441,8 +441,8 @@ func GeometryTposeToTrgeometry(gs *TRGeometrySeqSet, temp *Temporal) (*Temporal, } // GeometryFromEWKB is the portable fromEWKB of MEOS geo_from_ewkb. -func GeometryFromEWKB(wkb unsafe.Pointer, wkb_size uint, srid int32) (*TRGeometrySeqSet, error) { - return GeoFromEWKB(wkb, wkb_size, srid) +func GeometryFromEWKB(wkb []byte, srid int32) (*TRGeometrySeqSet, error) { + return GeoFromEWKB(wkb, srid) } // GeometryFromMFJSON is the portable fromMFJSON of MEOS geo_from_geojson. diff --git a/types/geomset.go b/types/geomset.go index 6433c84..86bb65d 100644 --- a/types/geomset.go +++ b/types/geomset.go @@ -33,8 +33,8 @@ func GeomSetIn(str string) (*Set, error) { } // GeomSetFromEWKB is the portable fromEWKB of MEOS set_from_wkb. -func GeomSetFromEWKB(wkb unsafe.Pointer, size uint) (*GeomSet, error) { - r, err := SetFromWKB(wkb, size) +func GeomSetFromEWKB(wkb []byte) (*GeomSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -78,8 +78,8 @@ func GeomSetFromText(str string) (*GeomSet, error) { } // GeomSetFromWKB is the portable fromWKB of MEOS set_from_wkb. -func GeomSetFromWKB(wkb unsafe.Pointer, size uint) (*GeomSet, error) { - r, err := SetFromWKB(wkb, size) +func GeomSetFromWKB(wkb []byte) (*GeomSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/h3indexset.go b/types/h3indexset.go index b9d74c8..3cdfe82 100644 --- a/types/h3indexset.go +++ b/types/h3indexset.go @@ -108,8 +108,8 @@ func (x *H3IndexSet) CoverCells(resolution int32) (*Set, error) { } // H3IndexSetFromEWKB is the portable fromEWKB of MEOS set_from_wkb. -func H3IndexSetFromEWKB(wkb unsafe.Pointer, size uint) (*H3IndexSet, error) { - r, err := SetFromWKB(wkb, size) +func H3IndexSetFromEWKB(wkb []byte) (*H3IndexSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -153,8 +153,8 @@ func H3IndexSetFromText(str string) (*H3IndexSet, error) { } // H3IndexSetFromWKB is the portable fromWKB of MEOS set_from_wkb. -func H3IndexSetFromWKB(wkb unsafe.Pointer, size uint) (*H3IndexSet, error) { - r, err := SetFromWKB(wkb, size) +func H3IndexSetFromWKB(wkb []byte) (*H3IndexSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/intset.go b/types/intset.go index 842508a..b2ee352 100644 --- a/types/intset.go +++ b/types/intset.go @@ -131,8 +131,8 @@ func IntSetFromText(str string) (*IntSet, error) { } // IntSetFromWKB is the portable fromWKB of MEOS set_from_wkb. -func IntSetFromWKB(wkb unsafe.Pointer, size uint) (*IntSet, error) { - r, err := SetFromWKB(wkb, size) +func IntSetFromWKB(wkb []byte) (*IntSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/intspan.go b/types/intspan.go index ab72d58..6c02bd6 100644 --- a/types/intspan.go +++ b/types/intspan.go @@ -155,8 +155,8 @@ func IntSpanFromText(str string) (*IntSpan, error) { } // IntSpanFromWKB is the portable fromWKB of MEOS span_from_wkb. -func IntSpanFromWKB(wkb unsafe.Pointer, size uint) (*IntSpan, error) { - r, err := SpanFromWKB(wkb, size) +func IntSpanFromWKB(wkb []byte) (*IntSpan, error) { + r, err := SpanFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/intspanset.go b/types/intspanset.go index a0a2b15..22b1892 100644 --- a/types/intspanset.go +++ b/types/intspanset.go @@ -119,8 +119,8 @@ func IntSpanSetFromText(str string) (*IntSpanSet, error) { } // IntSpanSetFromWKB is the portable fromWKB of MEOS spanset_from_wkb. -func IntSpanSetFromWKB(wkb unsafe.Pointer, size uint) (*IntSpanSet, error) { - r, err := SpanSetFromWKB(wkb, size) +func IntSpanSetFromWKB(wkb []byte) (*IntSpanSet, error) { + r, err := SpanSetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/jsonbset.go b/types/jsonbset.go index b5f9060..0a7512e 100644 --- a/types/jsonbset.go +++ b/types/jsonbset.go @@ -356,8 +356,8 @@ func JsonbSetFromText(str string) (*JsonbSet, error) { } // JsonbSetFromWKB is the portable fromWKB of MEOS set_from_wkb. -func JsonbSetFromWKB(wkb unsafe.Pointer, size uint) (*JsonbSet, error) { - r, err := SetFromWKB(wkb, size) +func JsonbSetFromWKB(wkb []byte) (*JsonbSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/npoint.go b/types/npoint.go index 6f5b058..7be8531 100644 --- a/types/npoint.go +++ b/types/npoint.go @@ -24,12 +24,13 @@ func NpointFromPointer(p unsafe.Pointer) *Npoint { } // AsEWKB is MEOS npoint_as_ewkb. -func (x *Npoint) AsEWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.NpointAsEWKB(functions.NpointFromPointer(x.Pointer()), variant, size_out) +func (x *Npoint) AsEWKB(variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.NpointAsEWKB(functions.NpointFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // AsEWKT is MEOS npoint_as_ewkt. @@ -42,8 +43,9 @@ func (x *Npoint) AsEWKT(maxdd int) (string, error) { } // AsHexEWKB is MEOS npoint_as_hexewkb. -func (x *Npoint) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.NpointAsHexewkb(functions.NpointFromPointer(x.Pointer()), variant, size_out) +func (x *Npoint) AsHexEWKB(variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.NpointAsHexewkb(functions.NpointFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } @@ -51,8 +53,9 @@ func (x *Npoint) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, erro } // AsHexWKB is MEOS npoint_as_hexwkb. -func (x *Npoint) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.NpointAsHexwkb(functions.NpointFromPointer(x.Pointer()), variant, size_out) +func (x *Npoint) AsHexWKB(variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.NpointAsHexwkb(functions.NpointFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } @@ -69,12 +72,13 @@ func (x *Npoint) AsText(maxdd int) (string, error) { } // AsWKB is MEOS npoint_as_wkb. -func (x *Npoint) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.NpointAsWKB(functions.NpointFromPointer(x.Pointer()), variant, size_out) +func (x *Npoint) AsWKB(variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.NpointAsWKB(functions.NpointFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // NpointFromHexWKB is MEOS npoint_from_hexwkb. @@ -87,8 +91,12 @@ func NpointFromHexWKB(hexwkb string) (*Npoint, error) { } // NpointFromWKB is MEOS npoint_from_wkb. -func NpointFromWKB(wkb unsafe.Pointer, size uint) (*Npoint, error) { - _r0, _err := functions.NpointFromWKB(wkb, size) +func NpointFromWKB(wkb []byte) (*Npoint, error) { + var _p_wkb unsafe.Pointer + if len(wkb) > 0 { + _p_wkb = unsafe.Pointer(&wkb[0]) + } + _r0, _err := functions.NpointFromWKB(_p_wkb, uint(len(wkb))) if _err != nil { return nil, _err } @@ -303,8 +311,8 @@ func (x *Npoint) ToSet() (*Set, error) { } // NpointFromEWKB is the portable fromEWKB of MEOS npoint_from_wkb. -func NpointFromEWKB(wkb unsafe.Pointer, size uint) (*Npoint, error) { - return NpointFromWKB(wkb, size) +func NpointFromEWKB(wkb []byte) (*Npoint, error) { + return NpointFromWKB(wkb) } // NpointFromEWKT is the portable fromEWKT of MEOS npoint_in. diff --git a/types/npointset.go b/types/npointset.go index 633fd06..0317bc4 100644 --- a/types/npointset.go +++ b/types/npointset.go @@ -99,8 +99,8 @@ func (x *NpointSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { } // NpointSetFromEWKB is the portable fromEWKB of MEOS set_from_wkb. -func NpointSetFromEWKB(wkb unsafe.Pointer, size uint) (*NpointSet, error) { - r, err := SetFromWKB(wkb, size) +func NpointSetFromEWKB(wkb []byte) (*NpointSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -144,8 +144,8 @@ func NpointSetFromText(str string) (*NpointSet, error) { } // NpointSetFromWKB is the portable fromWKB of MEOS set_from_wkb. -func NpointSetFromWKB(wkb unsafe.Pointer, size uint) (*NpointSet, error) { - r, err := SetFromWKB(wkb, size) +func NpointSetFromWKB(wkb []byte) (*NpointSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/nsegment.go b/types/nsegment.go index 7829954..e164d84 100644 --- a/types/nsegment.go +++ b/types/nsegment.go @@ -24,8 +24,9 @@ func NsegmentFromPointer(p unsafe.Pointer) *Nsegment { } // AsHexEWKB is MEOS nsegment_as_hexewkb. -func (x *Nsegment) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.NsegmentAsHexewkb(functions.NsegmentFromPointer(x.Pointer()), variant, size_out) +func (x *Nsegment) AsHexEWKB(variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.NsegmentAsHexewkb(functions.NsegmentFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } @@ -33,8 +34,9 @@ func (x *Nsegment) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, er } // AsHexWKB is MEOS nsegment_as_hexwkb. -func (x *Nsegment) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.NsegmentAsHexwkb(functions.NsegmentFromPointer(x.Pointer()), variant, size_out) +func (x *Nsegment) AsHexWKB(variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.NsegmentAsHexwkb(functions.NsegmentFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } @@ -42,12 +44,13 @@ func (x *Nsegment) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, err } // AsWKB is MEOS nsegment_as_wkb. -func (x *Nsegment) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.NsegmentAsWKB(functions.NsegmentFromPointer(x.Pointer()), variant, size_out) +func (x *Nsegment) AsWKB(variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.NsegmentAsWKB(functions.NsegmentFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // NsegmentFromHexWKB is MEOS nsegment_from_hexwkb. @@ -60,8 +63,12 @@ func NsegmentFromHexWKB(hexwkb string) (*Nsegment, error) { } // NsegmentFromWKB is MEOS nsegment_from_wkb. -func NsegmentFromWKB(wkb unsafe.Pointer, size uint) (*Nsegment, error) { - _r0, _err := functions.NsegmentFromWKB(wkb, size) +func NsegmentFromWKB(wkb []byte) (*Nsegment, error) { + var _p_wkb unsafe.Pointer + if len(wkb) > 0 { + _p_wkb = unsafe.Pointer(&wkb[0]) + } + _r0, _err := functions.NsegmentFromWKB(_p_wkb, uint(len(wkb))) if _err != nil { return nil, _err } @@ -87,12 +94,13 @@ func (x *Nsegment) Out(maxdd int) (string, error) { } // AsEWKB is MEOS nsegment_as_ewkb. -func (x *Nsegment) AsEWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.NsegmentAsEWKB(functions.NsegmentFromPointer(x.Pointer()), variant, size_out) +func (x *Nsegment) AsEWKB(variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.NsegmentAsEWKB(functions.NsegmentFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // AsEWKT is MEOS nsegment_as_ewkt. @@ -258,8 +266,8 @@ func (x *Nsegment) Ne(ns2 *Nsegment) (bool, error) { } // NsegmentFromEWKB is the portable fromEWKB of MEOS nsegment_from_wkb. -func NsegmentFromEWKB(wkb unsafe.Pointer, size uint) (*Nsegment, error) { - return NsegmentFromWKB(wkb, size) +func NsegmentFromEWKB(wkb []byte) (*Nsegment, error) { + return NsegmentFromWKB(wkb) } // NsegmentFromEWKT is the portable fromEWKT of MEOS nsegment_in. diff --git a/types/pcpatchset.go b/types/pcpatchset.go index f3074b1..311eee0 100644 --- a/types/pcpatchset.go +++ b/types/pcpatchset.go @@ -90,8 +90,8 @@ func (x *PcpatchSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { } // PcpatchSetFromEWKB is the portable fromEWKB of MEOS set_from_wkb. -func PcpatchSetFromEWKB(wkb unsafe.Pointer, size uint) (*PcpatchSet, error) { - r, err := SetFromWKB(wkb, size) +func PcpatchSetFromEWKB(wkb []byte) (*PcpatchSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -135,8 +135,8 @@ func PcpatchSetFromText(str string) (*PcpatchSet, error) { } // PcpatchSetFromWKB is the portable fromWKB of MEOS set_from_wkb. -func PcpatchSetFromWKB(wkb unsafe.Pointer, size uint) (*PcpatchSet, error) { - r, err := SetFromWKB(wkb, size) +func PcpatchSetFromWKB(wkb []byte) (*PcpatchSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/pcpointset.go b/types/pcpointset.go index d1cdde3..033bf24 100644 --- a/types/pcpointset.go +++ b/types/pcpointset.go @@ -90,8 +90,8 @@ func (x *PcpointSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { } // PcpointSetFromEWKB is the portable fromEWKB of MEOS set_from_wkb. -func PcpointSetFromEWKB(wkb unsafe.Pointer, size uint) (*PcpointSet, error) { - r, err := SetFromWKB(wkb, size) +func PcpointSetFromEWKB(wkb []byte) (*PcpointSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -135,8 +135,8 @@ func PcpointSetFromText(str string) (*PcpointSet, error) { } // PcpointSetFromWKB is the portable fromWKB of MEOS set_from_wkb. -func PcpointSetFromWKB(wkb unsafe.Pointer, size uint) (*PcpointSet, error) { - r, err := SetFromWKB(wkb, size) +func PcpointSetFromWKB(wkb []byte) (*PcpointSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/pose.go b/types/pose.go index 7e6a844..8a314d5 100644 --- a/types/pose.go +++ b/types/pose.go @@ -24,12 +24,13 @@ func PoseFromPointer(p unsafe.Pointer) *Pose { } // AsEWKB is MEOS pose_as_ewkb. -func (x *Pose) AsEWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.PoseAsEWKB(functions.PoseFromPointer(x.Pointer()), variant, size_out) +func (x *Pose) AsEWKB(variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.PoseAsEWKB(functions.PoseFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // AsEWKT is MEOS pose_as_ewkt. @@ -42,8 +43,9 @@ func (x *Pose) AsEWKT(maxdd int) (string, error) { } // AsHexEWKB is MEOS pose_as_hexewkb. -func (x *Pose) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.PoseAsHexewkb(functions.PoseFromPointer(x.Pointer()), variant, size_out) +func (x *Pose) AsHexEWKB(variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.PoseAsHexewkb(functions.PoseFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } @@ -51,8 +53,9 @@ func (x *Pose) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) } // AsHexWKB is MEOS pose_as_hexwkb. -func (x *Pose) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.PoseAsHexwkb(functions.PoseFromPointer(x.Pointer()), variant, size_out) +func (x *Pose) AsHexWKB(variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.PoseAsHexwkb(functions.PoseFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } @@ -69,17 +72,22 @@ func (x *Pose) AsText(maxdd int) (string, error) { } // AsWKB is MEOS pose_as_wkb. -func (x *Pose) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.PoseAsWKB(functions.PoseFromPointer(x.Pointer()), variant, size_out) +func (x *Pose) AsWKB(variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.PoseAsWKB(functions.PoseFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // PoseFromWKB is MEOS pose_from_wkb. -func PoseFromWKB(wkb unsafe.Pointer, size uint) (*Pose, error) { - _r0, _err := functions.PoseFromWKB(wkb, size) +func PoseFromWKB(wkb []byte) (*Pose, error) { + var _p_wkb unsafe.Pointer + if len(wkb) > 0 { + _p_wkb = unsafe.Pointer(&wkb[0]) + } + _r0, _err := functions.PoseFromWKB(_p_wkb, uint(len(wkb))) if _err != nil { return nil, _err } @@ -483,8 +491,8 @@ func (x *Pose) ToPosechain() (unsafe.Pointer, error) { } // PoseFromEWKB is the portable fromEWKB of MEOS pose_from_wkb. -func PoseFromEWKB(wkb unsafe.Pointer, size uint) (*Pose, error) { - return PoseFromWKB(wkb, size) +func PoseFromEWKB(wkb []byte) (*Pose, error) { + return PoseFromWKB(wkb) } // PoseFromEWKT is the portable fromEWKT of MEOS pose_from_text. diff --git a/types/posechain.go b/types/posechain.go index be4000f..6218370 100644 --- a/types/posechain.go +++ b/types/posechain.go @@ -51,12 +51,13 @@ func PoseChainAsText(pc unsafe.Pointer, maxdd int) (string, error) { } // PoseChainAsEWKB is MEOS posechain_as_ewkb. -func PoseChainAsEWKB(pc unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.PosechainAsEWKB(pc, variant, size_out) +func PoseChainAsEWKB(pc unsafe.Pointer, variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.PosechainAsEWKB(pc, variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // PoseChainAsEWKT is MEOS posechain_as_ewkt. @@ -69,17 +70,19 @@ func PoseChainAsEWKT(pc unsafe.Pointer, maxdd int) (string, error) { } // PoseChainAsWKB is MEOS posechain_as_wkb. -func PoseChainAsWKB(pc unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.PosechainAsWKB(pc, variant, size_out) +func PoseChainAsWKB(pc unsafe.Pointer, variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.PosechainAsWKB(pc, variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // PoseChainAsHexEWKB is MEOS posechain_as_hexewkb. -func PoseChainAsHexEWKB(pc unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.PosechainAsHexewkb(pc, variant, size_out) +func PoseChainAsHexEWKB(pc unsafe.Pointer, variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.PosechainAsHexewkb(pc, variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } @@ -87,8 +90,9 @@ func PoseChainAsHexEWKB(pc unsafe.Pointer, variant uint8, size_out unsafe.Pointe } // PoseChainAsHexWKB is MEOS posechain_as_hexwkb. -func PoseChainAsHexWKB(pc unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.PosechainAsHexwkb(pc, variant, size_out) +func PoseChainAsHexWKB(pc unsafe.Pointer, variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.PosechainAsHexwkb(pc, variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } @@ -96,8 +100,12 @@ func PoseChainAsHexWKB(pc unsafe.Pointer, variant uint8, size_out unsafe.Pointer } // PoseChainFromWKB is MEOS posechain_from_wkb. -func PoseChainFromWKB(wkb unsafe.Pointer, size uint) (unsafe.Pointer, error) { - _r0, _err := functions.PosechainFromWKB(wkb, size) +func PoseChainFromWKB(wkb []byte) (unsafe.Pointer, error) { + var _p_wkb unsafe.Pointer + if len(wkb) > 0 { + _p_wkb = unsafe.Pointer(&wkb[0]) + } + _r0, _err := functions.PosechainFromWKB(_p_wkb, uint(len(wkb))) if _err != nil { return nil, _err } @@ -384,8 +392,8 @@ func PoseChainToSet(pc unsafe.Pointer) (*Set, error) { } // PoseChainFromEWKB is the portable fromEWKB of MEOS posechain_from_wkb. -func PoseChainFromEWKB(wkb unsafe.Pointer, size uint) (unsafe.Pointer, error) { - return PoseChainFromWKB(wkb, size) +func PoseChainFromEWKB(wkb []byte) (unsafe.Pointer, error) { + return PoseChainFromWKB(wkb) } // PoseChainFromEWKT is the portable fromEWKT of MEOS posechain_in. diff --git a/types/posechainset.go b/types/posechainset.go index 31f9400..f1f9aa4 100644 --- a/types/posechainset.go +++ b/types/posechainset.go @@ -78,8 +78,8 @@ func (x *PoseChainSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { } // PoseChainSetFromEWKB is the portable fromEWKB of MEOS set_from_wkb. -func PoseChainSetFromEWKB(wkb unsafe.Pointer, size uint) (*PoseChainSet, error) { - r, err := SetFromWKB(wkb, size) +func PoseChainSetFromEWKB(wkb []byte) (*PoseChainSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -123,8 +123,8 @@ func PoseChainSetFromText(str string) (*PoseChainSet, error) { } // PoseChainSetFromWKB is the portable fromWKB of MEOS set_from_wkb. -func PoseChainSetFromWKB(wkb unsafe.Pointer, size uint) (*PoseChainSet, error) { - r, err := SetFromWKB(wkb, size) +func PoseChainSetFromWKB(wkb []byte) (*PoseChainSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/poseset.go b/types/poseset.go index a539738..3d603ed 100644 --- a/types/poseset.go +++ b/types/poseset.go @@ -90,8 +90,8 @@ func (x *PoseSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { } // PoseSetFromEWKB is the portable fromEWKB of MEOS set_from_wkb. -func PoseSetFromEWKB(wkb unsafe.Pointer, size uint) (*PoseSet, error) { - r, err := SetFromWKB(wkb, size) +func PoseSetFromEWKB(wkb []byte) (*PoseSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -135,8 +135,8 @@ func PoseSetFromText(str string) (*PoseSet, error) { } // PoseSetFromWKB is the portable fromWKB of MEOS set_from_wkb. -func PoseSetFromWKB(wkb unsafe.Pointer, size uint) (*PoseSet, error) { - r, err := SetFromWKB(wkb, size) +func PoseSetFromWKB(wkb []byte) (*PoseSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/quadbinset.go b/types/quadbinset.go index 4e588c9..9ac82bb 100644 --- a/types/quadbinset.go +++ b/types/quadbinset.go @@ -126,8 +126,8 @@ func (x *QuadbinSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { } // QuadbinSetFromEWKB is the portable fromEWKB of MEOS set_from_wkb. -func QuadbinSetFromEWKB(wkb unsafe.Pointer, size uint) (*QuadbinSet, error) { - r, err := SetFromWKB(wkb, size) +func QuadbinSetFromEWKB(wkb []byte) (*QuadbinSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -171,8 +171,8 @@ func QuadbinSetFromText(str string) (*QuadbinSet, error) { } // QuadbinSetFromWKB is the portable fromWKB of MEOS set_from_wkb. -func QuadbinSetFromWKB(wkb unsafe.Pointer, size uint) (*QuadbinSet, error) { - r, err := SetFromWKB(wkb, size) +func QuadbinSetFromWKB(wkb []byte) (*QuadbinSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/raquet.go b/types/raquet.go index 20d39e4..a8cb689 100644 --- a/types/raquet.go +++ b/types/raquet.go @@ -60,8 +60,12 @@ func RaquetOut(rq unsafe.Pointer) (string, error) { } // RaquetFromWKB is MEOS raquet_from_wkb. -func RaquetFromWKB(wkb unsafe.Pointer, size uint) (unsafe.Pointer, error) { - _r0, _err := functions.RaquetFromWKB(wkb, size) +func RaquetFromWKB(wkb []byte) (unsafe.Pointer, error) { + var _p_wkb unsafe.Pointer + if len(wkb) > 0 { + _p_wkb = unsafe.Pointer(&wkb[0]) + } + _r0, _err := functions.RaquetFromWKB(_p_wkb, uint(len(wkb))) if _err != nil { return nil, _err } @@ -78,17 +82,19 @@ func RaquetFromHexWKB(hexwkb string) (unsafe.Pointer, error) { } // RaquetAsWKB is MEOS raquet_as_wkb. -func RaquetAsWKB(rq unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.RaquetAsWKB(rq, variant, size_out) +func RaquetAsWKB(rq unsafe.Pointer, variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.RaquetAsWKB(rq, variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // RaquetAsHexWKB is MEOS raquet_as_hexwkb. -func RaquetAsHexWKB(rq unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.RaquetAsHexwkb(rq, variant, size_out) +func RaquetAsHexWKB(rq unsafe.Pointer, variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.RaquetAsHexwkb(rq, variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } @@ -96,8 +102,12 @@ func RaquetAsHexWKB(rq unsafe.Pointer, variant uint8, size_out unsafe.Pointer) ( } // RaquetMake is MEOS raquet_make. -func RaquetMake(quadbin uint64, width int32, height int32, pixtype functions.MeosPixType, nodata float64, has_nodata bool, pixels unsafe.Pointer, pixels_size uint) (unsafe.Pointer, error) { - _r0, _err := functions.RaquetMake(quadbin, width, height, pixtype, nodata, has_nodata, pixels, pixels_size) +func RaquetMake(quadbin uint64, width int32, height int32, pixtype functions.MeosPixType, nodata float64, has_nodata bool, pixels []byte) (unsafe.Pointer, error) { + var _p_pixels unsafe.Pointer + if len(pixels) > 0 { + _p_pixels = unsafe.Pointer(&pixels[0]) + } + _r0, _err := functions.RaquetMake(quadbin, width, height, pixtype, nodata, has_nodata, _p_pixels, uint(len(pixels))) if _err != nil { return nil, _err } @@ -123,8 +133,12 @@ func RaquetRead(path string, quadbin uint64) (unsafe.Pointer, error) { } // RaquetReadBytes is MEOS raquet_read_bytes. -func RaquetReadBytes(data unsafe.Pointer, size uint, quadbin uint64) (unsafe.Pointer, error) { - _r0, _err := functions.RaquetReadBytes(data, size, quadbin) +func RaquetReadBytes(data []byte, quadbin uint64) (unsafe.Pointer, error) { + var _p_data unsafe.Pointer + if len(data) > 0 { + _p_data = unsafe.Pointer(&data[0]) + } + _r0, _err := functions.RaquetReadBytes(_p_data, uint(len(data)), quadbin) if _err != nil { return nil, _err } @@ -189,12 +203,13 @@ func RaquetBandNodataValue(rq unsafe.Pointer) (float64, bool, error) { } // RaquetPixels is MEOS raquet_pixels. -func RaquetPixels(rq unsafe.Pointer, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.RaquetPixels(rq, size_out) +func RaquetPixels(rq unsafe.Pointer) ([]byte, error) { + var _size uint64 + _r0, _err := functions.RaquetPixels(rq, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // RaquetHash is MEOS raquet_hash. diff --git a/types/raster.go b/types/raster.go index 8c21e71..4d81246 100644 --- a/types/raster.go +++ b/types/raster.go @@ -24,8 +24,12 @@ func RasterFromPointer(p unsafe.Pointer) *Raster { } // RasterFromWKB is MEOS raster_from_wkb. -func RasterFromWKB(wkb unsafe.Pointer, size uint) (unsafe.Pointer, error) { - _r0, _err := functions.RasterFromWKB(wkb, size) +func RasterFromWKB(wkb []byte) (unsafe.Pointer, error) { + var _p_wkb unsafe.Pointer + if len(wkb) > 0 { + _p_wkb = unsafe.Pointer(&wkb[0]) + } + _r0, _err := functions.RasterFromWKB(_p_wkb, uint(len(wkb))) if _err != nil { return nil, _err } @@ -42,17 +46,19 @@ func RasterFromHexWKB(hexwkb string) (unsafe.Pointer, error) { } // RasterAsWKB is MEOS raster_as_wkb. -func RasterAsWKB(rast unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.RasterAsWKB(rast, variant, size_out) +func RasterAsWKB(rast unsafe.Pointer, variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.RasterAsWKB(rast, variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // RasterAsHexWKB is MEOS raster_as_hexwkb. -func RasterAsHexWKB(rast unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.RasterAsHexwkb(rast, variant, size_out) +func RasterAsHexWKB(rast unsafe.Pointer, variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.RasterAsHexwkb(rast, variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } @@ -69,8 +75,12 @@ func RasterCopy(rast unsafe.Pointer) (unsafe.Pointer, error) { } // RasterMake is MEOS raster_make. -func RasterMake(width int, height int, upperleftx float64, upperlefty float64, scalex float64, scaley float64, skewx float64, skewy float64, srid int32, pixeltype string, nodataval float64, has_nodata bool, pixels unsafe.Pointer, size uint) (unsafe.Pointer, error) { - _r0, _err := functions.RasterMake(width, height, upperleftx, upperlefty, scalex, scaley, skewx, skewy, srid, pixeltype, nodataval, has_nodata, pixels, size) +func RasterMake(width int, height int, upperleftx float64, upperlefty float64, scalex float64, scaley float64, skewx float64, skewy float64, srid int32, pixeltype string, nodataval float64, has_nodata bool, pixels []byte) (unsafe.Pointer, error) { + var _p_pixels unsafe.Pointer + if len(pixels) > 0 { + _p_pixels = unsafe.Pointer(&pixels[0]) + } + _r0, _err := functions.RasterMake(width, height, upperleftx, upperlefty, scalex, scaley, skewx, skewy, srid, pixeltype, nodataval, has_nodata, _p_pixels, uint(len(pixels))) if _err != nil { return nil, _err } @@ -234,12 +244,13 @@ func RasterBandNodataValue(rast unsafe.Pointer, band int) (float64, bool, error) } // RasterBandPixels is MEOS raster_band_pixels. -func RasterBandPixels(rast unsafe.Pointer, band int, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.RasterBandPixels(rast, band, size_out) +func RasterBandPixels(rast unsafe.Pointer, band int) ([]byte, error) { + var _size uint64 + _r0, _err := functions.RasterBandPixels(rast, band, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // RasterClip is MEOS raster_clip. @@ -468,8 +479,12 @@ func RasterMinusValueGdal(traj *Temporal, path string, band int, vspan *Span) (* } // RasterTileValueQuadbin is MEOS raster_tile_value_quadbin. -func RasterTileValueQuadbin(traj *Temporal, pixels unsafe.Pointer, pixels_size uint, width int32, height int32, quadbin uint64, pixtype functions.MeosPixType, nodata float64, has_nodata bool) (*Temporal, error) { - _r0, _err := functions.RasterTileValueQuadbin(functions.TemporalFromPointer(traj.Pointer()), pixels, pixels_size, width, height, quadbin, pixtype, nodata, has_nodata) +func RasterTileValueQuadbin(traj *Temporal, pixels []byte, width int32, height int32, quadbin uint64, pixtype functions.MeosPixType, nodata float64, has_nodata bool) (*Temporal, error) { + var _p_pixels unsafe.Pointer + if len(pixels) > 0 { + _p_pixels = unsafe.Pointer(&pixels[0]) + } + _r0, _err := functions.RasterTileValueQuadbin(functions.TemporalFromPointer(traj.Pointer()), _p_pixels, uint(len(pixels)), width, height, quadbin, pixtype, nodata, has_nodata) if _err != nil { return nil, _err } diff --git a/types/s2cellset.go b/types/s2cellset.go index 3e0156d..1a65f92 100644 --- a/types/s2cellset.go +++ b/types/s2cellset.go @@ -117,8 +117,8 @@ func (x *S2CellSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { } // S2CellSetFromEWKB is the portable fromEWKB of MEOS set_from_wkb. -func S2CellSetFromEWKB(wkb unsafe.Pointer, size uint) (*S2CellSet, error) { - r, err := SetFromWKB(wkb, size) +func S2CellSetFromEWKB(wkb []byte) (*S2CellSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -162,8 +162,8 @@ func S2CellSetFromText(str string) (*S2CellSet, error) { } // S2CellSetFromWKB is the portable fromWKB of MEOS set_from_wkb. -func S2CellSetFromWKB(wkb unsafe.Pointer, size uint) (*S2CellSet, error) { - r, err := SetFromWKB(wkb, size) +func S2CellSetFromWKB(wkb []byte) (*S2CellSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/set.go b/types/set.go index 1500f3c..a6ac658 100644 --- a/types/set.go +++ b/types/set.go @@ -24,8 +24,9 @@ func SetFromPointer(p unsafe.Pointer) *Set { } // AsHexWKB is MEOS set_as_hexwkb. -func (x *Set) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.SetAsHexwkb(functions.SetFromPointer(x.Pointer()), variant, size_out) +func (x *Set) AsHexWKB(variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.SetAsHexwkb(functions.SetFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } @@ -33,12 +34,13 @@ func (x *Set) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) { } // AsWKB is MEOS set_as_wkb. -func (x *Set) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.SetAsWKB(functions.SetFromPointer(x.Pointer()), variant, size_out) +func (x *Set) AsWKB(variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.SetAsWKB(functions.SetFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // SetFromHexWKB is MEOS set_from_hexwkb. @@ -51,8 +53,12 @@ func SetFromHexWKB(hexwkb string) (*Set, error) { } // SetFromWKB is MEOS set_from_wkb. -func SetFromWKB(wkb unsafe.Pointer, size uint) (*Set, error) { - _r0, _err := functions.SetFromWKB(wkb, size) +func SetFromWKB(wkb []byte) (*Set, error) { + var _p_wkb unsafe.Pointer + if len(wkb) > 0 { + _p_wkb = unsafe.Pointer(&wkb[0]) + } + _r0, _err := functions.SetFromWKB(_p_wkb, uint(len(wkb))) if _err != nil { return nil, _err } @@ -195,12 +201,13 @@ func (x *Set) Ne(s2 *Set) (bool, error) { } // Sortkey is MEOS set_sortkey. -func (x *Set) Sortkey(size unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.SetSortkey(functions.SetFromPointer(x.Pointer()), size) +func (x *Set) Sortkey() ([]byte, error) { + var _size uint64 + _r0, _err := functions.SetSortkey(functions.SetFromPointer(x.Pointer()), unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // Spans is MEOS set_spans. diff --git a/types/span.go b/types/span.go index 4d1131c..8c4967f 100644 --- a/types/span.go +++ b/types/span.go @@ -24,8 +24,9 @@ func SpanFromPointer(p unsafe.Pointer) *Span { } // AsHexWKB is MEOS span_as_hexwkb. -func (x *Span) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.SpanAsHexwkb(functions.SpanFromPointer(x.Pointer()), variant, size_out) +func (x *Span) AsHexWKB(variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.SpanAsHexwkb(functions.SpanFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } @@ -33,12 +34,13 @@ func (x *Span) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) } // AsWKB is MEOS span_as_wkb. -func (x *Span) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.SpanAsWKB(functions.SpanFromPointer(x.Pointer()), variant, size_out) +func (x *Span) AsWKB(variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.SpanAsWKB(functions.SpanFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // SpanFromHexWKB is MEOS span_from_hexwkb. @@ -51,8 +53,12 @@ func SpanFromHexWKB(hexwkb string) (*Span, error) { } // SpanFromWKB is MEOS span_from_wkb. -func SpanFromWKB(wkb unsafe.Pointer, size uint) (*Span, error) { - _r0, _err := functions.SpanFromWKB(wkb, size) +func SpanFromWKB(wkb []byte) (*Span, error) { + var _p_wkb unsafe.Pointer + if len(wkb) > 0 { + _p_wkb = unsafe.Pointer(&wkb[0]) + } + _r0, _err := functions.SpanFromWKB(_p_wkb, uint(len(wkb))) if _err != nil { return nil, _err } @@ -177,12 +183,13 @@ func (x *Span) Ne(s2 *Span) (bool, error) { } // Sortkey is MEOS span_sortkey. -func (x *Span) Sortkey(size unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.SpanSortkey(functions.SpanFromPointer(x.Pointer()), size) +func (x *Span) Sortkey() ([]byte, error) { + var _size uint64 + _r0, _err := functions.SpanSortkey(functions.SpanFromPointer(x.Pointer()), unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // ToTbox is MEOS span_to_tbox. diff --git a/types/spanset.go b/types/spanset.go index 4e9cbb0..2206c47 100644 --- a/types/spanset.go +++ b/types/spanset.go @@ -24,8 +24,9 @@ func SpanSetFromPointer(p unsafe.Pointer) *SpanSet { } // AsHexWKB is MEOS spanset_as_hexwkb. -func (x *SpanSet) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.SpansetAsHexwkb(functions.SpanSetFromPointer(x.Pointer()), variant, size_out) +func (x *SpanSet) AsHexWKB(variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.SpansetAsHexwkb(functions.SpanSetFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } @@ -33,12 +34,13 @@ func (x *SpanSet) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, erro } // AsWKB is MEOS spanset_as_wkb. -func (x *SpanSet) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.SpansetAsWKB(functions.SpanSetFromPointer(x.Pointer()), variant, size_out) +func (x *SpanSet) AsWKB(variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.SpansetAsWKB(functions.SpanSetFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // SpanSetFromHexWKB is MEOS spanset_from_hexwkb. @@ -51,8 +53,12 @@ func SpanSetFromHexWKB(hexwkb string) (*SpanSet, error) { } // SpanSetFromWKB is MEOS spanset_from_wkb. -func SpanSetFromWKB(wkb unsafe.Pointer, size uint) (*SpanSet, error) { - _r0, _err := functions.SpansetFromWKB(wkb, size) +func SpanSetFromWKB(wkb []byte) (*SpanSet, error) { + var _p_wkb unsafe.Pointer + if len(wkb) > 0 { + _p_wkb = unsafe.Pointer(&wkb[0]) + } + _r0, _err := functions.SpansetFromWKB(_p_wkb, uint(len(wkb))) if _err != nil { return nil, _err } @@ -240,12 +246,13 @@ func (x *SpanSet) Ne(ss2 *SpanSet) (bool, error) { } // Sortkey is MEOS spanset_sortkey. -func (x *SpanSet) Sortkey(size unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.SpansetSortkey(functions.SpanSetFromPointer(x.Pointer()), size) +func (x *SpanSet) Sortkey() ([]byte, error) { + var _size uint64 + _r0, _err := functions.SpansetSortkey(functions.SpanSetFromPointer(x.Pointer()), unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // Spans is MEOS spanset_spans. diff --git a/types/spatialset.go b/types/spatialset.go index 3af4c9f..c6af562 100644 --- a/types/spatialset.go +++ b/types/spatialset.go @@ -42,12 +42,13 @@ func (x *SpatialSet) AsText(maxdd int) (string, error) { } // AsEWKB is MEOS spatialset_as_ewkb. -func (x *SpatialSet) AsEWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.SpatialsetAsEWKB(functions.SetFromPointer(x.Pointer()), variant, size_out) +func (x *SpatialSet) AsEWKB(variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.SpatialsetAsEWKB(functions.SetFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // AsEWKT is MEOS spatialset_as_ewkt. @@ -60,8 +61,9 @@ func (x *SpatialSet) AsEWKT(maxdd int) (string, error) { } // AsHexEWKB is MEOS spatialset_as_hexewkb. -func (x *SpatialSet) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.SpatialsetAsHexewkb(functions.SetFromPointer(x.Pointer()), variant, size_out) +func (x *SpatialSet) AsHexEWKB(variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.SpatialsetAsHexewkb(functions.SetFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } diff --git a/types/stbox.go b/types/stbox.go index fbbc4d7..7f47165 100644 --- a/types/stbox.go +++ b/types/stbox.go @@ -24,17 +24,19 @@ func STBoxFromPointer(p unsafe.Pointer) *STBox { } // AsEWKB is MEOS stbox_as_ewkb. -func (x *STBox) AsEWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.STBOXAsEWKB(functions.STBoxFromPointer(x.Pointer()), variant, size_out) +func (x *STBox) AsEWKB(variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.STBOXAsEWKB(functions.STBoxFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // AsHexEWKB is MEOS stbox_as_hexewkb. -func (x *STBox) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.STBOXAsHexewkb(functions.STBoxFromPointer(x.Pointer()), variant, size_out) +func (x *STBox) AsHexEWKB(variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.STBOXAsHexewkb(functions.STBoxFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } @@ -42,8 +44,9 @@ func (x *STBox) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error } // AsHexWKB is MEOS stbox_as_hexwkb. -func (x *STBox) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.STBOXAsHexwkb(functions.STBoxFromPointer(x.Pointer()), variant, size_out) +func (x *STBox) AsHexWKB(variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.STBOXAsHexwkb(functions.STBoxFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } @@ -51,12 +54,13 @@ func (x *STBox) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) } // AsWKB is MEOS stbox_as_wkb. -func (x *STBox) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.STBOXAsWKB(functions.STBoxFromPointer(x.Pointer()), variant, size_out) +func (x *STBox) AsWKB(variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.STBOXAsWKB(functions.STBoxFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // STBoxFromHexWKB is MEOS stbox_from_hexwkb. @@ -69,8 +73,12 @@ func STBoxFromHexWKB(hexwkb string) (*STBox, error) { } // STBoxFromWKB is MEOS stbox_from_wkb. -func STBoxFromWKB(wkb unsafe.Pointer, size uint) (*STBox, error) { - _r0, _err := functions.STBOXFromWKB(wkb, size) +func STBoxFromWKB(wkb []byte) (*STBox, error) { + var _p_wkb unsafe.Pointer + if len(wkb) > 0 { + _p_wkb = unsafe.Pointer(&wkb[0]) + } + _r0, _err := functions.STBOXFromWKB(_p_wkb, uint(len(wkb))) if _err != nil { return nil, _err } @@ -468,12 +476,13 @@ func (x *STBox) Ne(box2 *STBox) (bool, error) { } // Sortkey is MEOS stbox_sortkey. -func (x *STBox) Sortkey(size unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.STBOXSortkey(functions.STBoxFromPointer(x.Pointer()), size) +func (x *STBox) Sortkey() ([]byte, error) { + var _size uint64 + _r0, _err := functions.STBOXSortkey(functions.STBoxFromPointer(x.Pointer()), unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // SpatialDistance is MEOS stbox_spatial_distance. @@ -504,8 +513,8 @@ func (x *STBox) SpaceTiles(xsize float64, ysize float64, zsize float64, sorigin } // STBoxFromEWKB is the portable fromEWKB of MEOS stbox_from_wkb. -func STBoxFromEWKB(wkb unsafe.Pointer, size uint) (*STBox, error) { - return STBoxFromWKB(wkb, size) +func STBoxFromEWKB(wkb []byte) (*STBox, error) { + return STBoxFromWKB(wkb) } // STBoxFromHexEWKB is the portable fromHexEWKB of MEOS stbox_from_hexwkb. diff --git a/types/tbigint.go b/types/tbigint.go index 2ca1fe1..b89bffd 100644 --- a/types/tbigint.go +++ b/types/tbigint.go @@ -287,8 +287,8 @@ func TBigintFromText(str string) (*TBigint, error) { } // TBigintFromWKB is the portable fromWKB of MEOS temporal_from_wkb. -func TBigintFromWKB(wkb unsafe.Pointer, size uint) (*TBigint, error) { - r, err := TemporalFromWKB(wkb, size) +func TBigintFromWKB(wkb []byte) (*TBigint, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/tbool.go b/types/tbool.go index ecb59fb..bcf07fd 100644 --- a/types/tbool.go +++ b/types/tbool.go @@ -188,8 +188,8 @@ func TBoolFromText(str string) (*TBool, error) { } // TBoolFromWKB is the portable fromWKB of MEOS temporal_from_wkb. -func TBoolFromWKB(wkb unsafe.Pointer, size uint) (*TBool, error) { - r, err := TemporalFromWKB(wkb, size) +func TBoolFromWKB(wkb []byte) (*TBool, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/tbox.go b/types/tbox.go index ae60a67..32634eb 100644 --- a/types/tbox.go +++ b/types/tbox.go @@ -24,8 +24,9 @@ func TBoxFromPointer(p unsafe.Pointer) *TBox { } // AsHexWKB is MEOS tbox_as_hexwkb. -func (x *TBox) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.TBOXAsHexwkb(functions.TBoxFromPointer(x.Pointer()), variant, size_out) +func (x *TBox) AsHexWKB(variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.TBOXAsHexwkb(functions.TBoxFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } @@ -33,12 +34,13 @@ func (x *TBox) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) } // AsWKB is MEOS tbox_as_wkb. -func (x *TBox) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.TBOXAsWKB(functions.TBoxFromPointer(x.Pointer()), variant, size_out) +func (x *TBox) AsWKB(variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.TBOXAsWKB(functions.TBoxFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // TBoxFromHexWKB is MEOS tbox_from_hexwkb. @@ -51,8 +53,12 @@ func TBoxFromHexWKB(hexwkb string) (*TBox, error) { } // TBoxFromWKB is MEOS tbox_from_wkb. -func TBoxFromWKB(wkb unsafe.Pointer, size uint) (*TBox, error) { - _r0, _err := functions.TBOXFromWKB(wkb, size) +func TBoxFromWKB(wkb []byte) (*TBox, error) { + var _p_wkb unsafe.Pointer + if len(wkb) > 0 { + _p_wkb = unsafe.Pointer(&wkb[0]) + } + _r0, _err := functions.TBOXFromWKB(_p_wkb, uint(len(wkb))) if _err != nil { return nil, _err } @@ -336,12 +342,13 @@ func (x *TBox) Ne(box2 *TBox) (bool, error) { } // Sortkey is MEOS tbox_sortkey. -func (x *TBox) Sortkey(size unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.TBOXSortkey(functions.TBoxFromPointer(x.Pointer()), size) +func (x *TBox) Sortkey() ([]byte, error) { + var _size uint64 + _r0, _err := functions.TBOXSortkey(functions.TBoxFromPointer(x.Pointer()), unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // TBoxGetValueTile is MEOS tbox_get_value_tile. diff --git a/types/tcbuffer.go b/types/tcbuffer.go index b863d37..bbf8b71 100644 --- a/types/tcbuffer.go +++ b/types/tcbuffer.go @@ -273,8 +273,8 @@ func (x *TCbuffer) MinusStbox(box *STBox, border_inc bool) (*Temporal, error) { } // TCbufferFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb. -func TCbufferFromEWKB(wkb unsafe.Pointer, size uint) (*TCbuffer, error) { - r, err := TemporalFromWKB(wkb, size) +func TCbufferFromEWKB(wkb []byte) (*TCbuffer, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -318,8 +318,8 @@ func TCbufferFromText(str string) (*TCbuffer, error) { } // TCbufferFromWKB is the portable fromWKB of MEOS temporal_from_wkb. -func TCbufferFromWKB(wkb unsafe.Pointer, size uint) (*TCbuffer, error) { - r, err := TemporalFromWKB(wkb, size) +func TCbufferFromWKB(wkb []byte) (*TCbuffer, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/temporal.go b/types/temporal.go index ee6edd4..2ec7271 100644 --- a/types/temporal.go +++ b/types/temporal.go @@ -26,8 +26,9 @@ func TemporalFromPointer(p unsafe.Pointer) *Temporal { } // AsHexWKB is MEOS temporal_as_hexwkb. -func (x *Temporal) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.TemporalAsHexwkb(functions.TemporalFromPointer(x.Pointer()), variant, size_out) +func (x *Temporal) AsHexWKB(variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.TemporalAsHexwkb(functions.TemporalFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } @@ -44,12 +45,13 @@ func (x *Temporal) AsMFJSON(option int, flags int, precision int, srs *string) ( } // AsWKB is MEOS temporal_as_wkb. -func (x *Temporal) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.TemporalAsWKB(functions.TemporalFromPointer(x.Pointer()), variant, size_out) +func (x *Temporal) AsWKB(variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.TemporalAsWKB(functions.TemporalFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // TemporalFromHexWKB is MEOS temporal_from_hexwkb. @@ -62,8 +64,12 @@ func TemporalFromHexWKB(hexwkb string) (*Temporal, error) { } // TemporalFromWKB is MEOS temporal_from_wkb. -func TemporalFromWKB(wkb unsafe.Pointer, size uint) (*Temporal, error) { - _r0, _err := functions.TemporalFromWKB(wkb, size) +func TemporalFromWKB(wkb []byte) (*Temporal, error) { + var _p_wkb unsafe.Pointer + if len(wkb) > 0 { + _p_wkb = unsafe.Pointer(&wkb[0]) + } + _r0, _err := functions.TemporalFromWKB(_p_wkb, uint(len(wkb))) if _err != nil { return nil, _err } @@ -677,12 +683,13 @@ func (x *Temporal) Ne(temp2 *Temporal) (bool, error) { } // Sortkey is MEOS temporal_sortkey. -func (x *Temporal) Sortkey(size unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.TemporalSortkey(functions.TemporalFromPointer(x.Pointer()), size) +func (x *Temporal) Sortkey() ([]byte, error) { + var _size uint64 + _r0, _err := functions.TemporalSortkey(functions.TemporalFromPointer(x.Pointer()), unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // Spans is MEOS temporal_spans. diff --git a/types/textset.go b/types/textset.go index 042e837..e465689 100644 --- a/types/textset.go +++ b/types/textset.go @@ -149,8 +149,8 @@ func TextSetFromText(str string) (*TextSet, error) { } // TextSetFromWKB is the portable fromWKB of MEOS set_from_wkb. -func TextSetFromWKB(wkb unsafe.Pointer, size uint) (*TextSet, error) { - r, err := SetFromWKB(wkb, size) +func TextSetFromWKB(wkb []byte) (*TextSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/tfloat.go b/types/tfloat.go index 1e84faf..457e02e 100644 --- a/types/tfloat.go +++ b/types/tfloat.go @@ -350,8 +350,8 @@ func TFloatFromText(str string) (*TFloat, error) { } // TFloatFromWKB is the portable fromWKB of MEOS temporal_from_wkb. -func TFloatFromWKB(wkb unsafe.Pointer, size uint) (*TFloat, error) { - r, err := TemporalFromWKB(wkb, size) +func TFloatFromWKB(wkb []byte) (*TFloat, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/tgeogpoint.go b/types/tgeogpoint.go index c298824..e891eb6 100644 --- a/types/tgeogpoint.go +++ b/types/tgeogpoint.go @@ -123,8 +123,8 @@ func (x *TGeogPoint) S2cellSplit(level int32, border_inc bool, cells unsafe.Poin } // TGeogPointFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb. -func TGeogPointFromEWKB(wkb unsafe.Pointer, size uint) (*TGeogPoint, error) { - r, err := TemporalFromWKB(wkb, size) +func TGeogPointFromEWKB(wkb []byte) (*TGeogPoint, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -168,8 +168,8 @@ func TGeogPointFromText(str string) (*TGeogPoint, error) { } // TGeogPointFromWKB is the portable fromWKB of MEOS temporal_from_wkb. -func TGeogPointFromWKB(wkb unsafe.Pointer, size uint) (*TGeogPoint, error) { - r, err := TemporalFromWKB(wkb, size) +func TGeogPointFromWKB(wkb []byte) (*TGeogPoint, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/tgeography.go b/types/tgeography.go index 7ad9ae1..4a94467 100644 --- a/types/tgeography.go +++ b/types/tgeography.go @@ -60,8 +60,8 @@ func (x *TGeography) ToTgeometry() (*Temporal, error) { } // TGeographyFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb. -func TGeographyFromEWKB(wkb unsafe.Pointer, size uint) (*TGeography, error) { - r, err := TemporalFromWKB(wkb, size) +func TGeographyFromEWKB(wkb []byte) (*TGeography, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -105,8 +105,8 @@ func TGeographyFromText(str string) (*TGeography, error) { } // TGeographyFromWKB is the portable fromWKB of MEOS temporal_from_wkb. -func TGeographyFromWKB(wkb unsafe.Pointer, size uint) (*TGeography, error) { - r, err := TemporalFromWKB(wkb, size) +func TGeographyFromWKB(wkb []byte) (*TGeography, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/tgeometry.go b/types/tgeometry.go index 2f73cd2..a0af001 100644 --- a/types/tgeometry.go +++ b/types/tgeometry.go @@ -69,8 +69,8 @@ func (x *TGeometry) ToTcbuffer() (*Temporal, error) { } // TGeometryFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb. -func TGeometryFromEWKB(wkb unsafe.Pointer, size uint) (*TGeometry, error) { - r, err := TemporalFromWKB(wkb, size) +func TGeometryFromEWKB(wkb []byte) (*TGeometry, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -114,8 +114,8 @@ func TGeometryFromText(str string) (*TGeometry, error) { } // TGeometryFromWKB is the portable fromWKB of MEOS temporal_from_wkb. -func TGeometryFromWKB(wkb unsafe.Pointer, size uint) (*TGeometry, error) { - r, err := TemporalFromWKB(wkb, size) +func TGeometryFromWKB(wkb []byte) (*TGeometry, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/tgeompoint.go b/types/tgeompoint.go index 85dee70..ed72097 100644 --- a/types/tgeompoint.go +++ b/types/tgeompoint.go @@ -123,8 +123,8 @@ func (x *TGeomPoint) S2cellSplit(level int32, border_inc bool, cells unsafe.Poin } // TGeomPointFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb. -func TGeomPointFromEWKB(wkb unsafe.Pointer, size uint) (*TGeomPoint, error) { - r, err := TemporalFromWKB(wkb, size) +func TGeomPointFromEWKB(wkb []byte) (*TGeomPoint, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -168,8 +168,8 @@ func TGeomPointFromText(str string) (*TGeomPoint, error) { } // TGeomPointFromWKB is the portable fromWKB of MEOS temporal_from_wkb. -func TGeomPointFromWKB(wkb unsafe.Pointer, size uint) (*TGeomPoint, error) { - r, err := TemporalFromWKB(wkb, size) +func TGeomPointFromWKB(wkb []byte) (*TGeomPoint, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/th3index.go b/types/th3index.go index 39a07e5..1f7706c 100644 --- a/types/th3index.go +++ b/types/th3index.go @@ -372,8 +372,8 @@ func (x *TH3Index) EdgeLength() (*Temporal, error) { } // TH3IndexFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb. -func TH3IndexFromEWKB(wkb unsafe.Pointer, size uint) (*TH3Index, error) { - r, err := TemporalFromWKB(wkb, size) +func TH3IndexFromEWKB(wkb []byte) (*TH3Index, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -417,8 +417,8 @@ func TH3IndexFromText(str string) (*TH3Index, error) { } // TH3IndexFromWKB is the portable fromWKB of MEOS temporal_from_wkb. -func TH3IndexFromWKB(wkb unsafe.Pointer, size uint) (*TH3Index, error) { - r, err := TemporalFromWKB(wkb, size) +func TH3IndexFromWKB(wkb []byte) (*TH3Index, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/tint.go b/types/tint.go index d6a4f33..d1fcf83 100644 --- a/types/tint.go +++ b/types/tint.go @@ -260,8 +260,8 @@ func TIntFromText(str string) (*TInt, error) { } // TIntFromWKB is the portable fromWKB of MEOS temporal_from_wkb. -func TIntFromWKB(wkb unsafe.Pointer, size uint) (*TInt, error) { - r, err := TemporalFromWKB(wkb, size) +func TIntFromWKB(wkb []byte) (*TInt, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/tjsonb.go b/types/tjsonb.go index 8e7e64b..0a39cd7 100644 --- a/types/tjsonb.go +++ b/types/tjsonb.go @@ -467,8 +467,8 @@ func TJsonbFromText(str string) (*TJsonb, error) { } // TJsonbFromWKB is the portable fromWKB of MEOS temporal_from_wkb. -func TJsonbFromWKB(wkb unsafe.Pointer, size uint) (*TJsonb, error) { - r, err := TemporalFromWKB(wkb, size) +func TJsonbFromWKB(wkb []byte) (*TJsonb, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/tnpoint.go b/types/tnpoint.go index ea46fb3..11039b7 100644 --- a/types/tnpoint.go +++ b/types/tnpoint.go @@ -282,8 +282,8 @@ func (x *TNpoint) MinusStbox(box *STBox, border_inc bool) (*Temporal, error) { } // TNpointFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb. -func TNpointFromEWKB(wkb unsafe.Pointer, size uint) (*TNpoint, error) { - r, err := TemporalFromWKB(wkb, size) +func TNpointFromEWKB(wkb []byte) (*TNpoint, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -327,8 +327,8 @@ func TNpointFromText(str string) (*TNpoint, error) { } // TNpointFromWKB is the portable fromWKB of MEOS temporal_from_wkb. -func TNpointFromWKB(wkb unsafe.Pointer, size uint) (*TNpoint, error) { - r, err := TemporalFromWKB(wkb, size) +func TNpointFromWKB(wkb []byte) (*TNpoint, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/tpcbox.go b/types/tpcbox.go index d394a26..01737d1 100644 --- a/types/tpcbox.go +++ b/types/tpcbox.go @@ -24,17 +24,19 @@ func TPCBoxFromPointer(p unsafe.Pointer) *TPCBox { } // AsEWKB is MEOS tpcbox_as_ewkb. -func (x *TPCBox) AsEWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.TpcboxAsEWKB(functions.TPCBoxFromPointer(x.Pointer()), variant, size_out) +func (x *TPCBox) AsEWKB(variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.TpcboxAsEWKB(functions.TPCBoxFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // AsHexEWKB is MEOS tpcbox_as_hexewkb. -func (x *TPCBox) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.TpcboxAsHexewkb(functions.TPCBoxFromPointer(x.Pointer()), variant, size_out) +func (x *TPCBox) AsHexEWKB(variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.TpcboxAsHexewkb(functions.TPCBoxFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } @@ -42,8 +44,9 @@ func (x *TPCBox) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, erro } // AsHexWKB is MEOS tpcbox_as_hexwkb. -func (x *TPCBox) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.TpcboxAsHexwkb(functions.TPCBoxFromPointer(x.Pointer()), variant, size_out) +func (x *TPCBox) AsHexWKB(variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.TpcboxAsHexwkb(functions.TPCBoxFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } @@ -51,12 +54,13 @@ func (x *TPCBox) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error } // AsWKB is MEOS tpcbox_as_wkb. -func (x *TPCBox) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.TpcboxAsWKB(functions.TPCBoxFromPointer(x.Pointer()), variant, size_out) +func (x *TPCBox) AsWKB(variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.TpcboxAsWKB(functions.TPCBoxFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // TPCBoxFromHexWKB is MEOS tpcbox_from_hexwkb. @@ -69,8 +73,12 @@ func TPCBoxFromHexWKB(hexwkb string) (*TPCBox, error) { } // TPCBoxFromWKB is MEOS tpcbox_from_wkb. -func TPCBoxFromWKB(wkb unsafe.Pointer, size uint) (*TPCBox, error) { - _r0, _err := functions.TpcboxFromWKB(wkb, size) +func TPCBoxFromWKB(wkb []byte) (*TPCBox, error) { + var _p_wkb unsafe.Pointer + if len(wkb) > 0 { + _p_wkb = unsafe.Pointer(&wkb[0]) + } + _r0, _err := functions.TpcboxFromWKB(_p_wkb, uint(len(wkb))) if _err != nil { return nil, _err } @@ -342,12 +350,13 @@ func (x *TPCBox) Ne(box2 *TPCBox) (bool, error) { } // Sortkey is MEOS tpcbox_sortkey. -func (x *TPCBox) Sortkey(size unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.TpcboxSortkey(functions.TPCBoxFromPointer(x.Pointer()), size) +func (x *TPCBox) Sortkey() ([]byte, error) { + var _size uint64 + _r0, _err := functions.TpcboxSortkey(functions.TPCBoxFromPointer(x.Pointer()), unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // Lt is MEOS tpcbox_lt. @@ -387,8 +396,8 @@ func (x *TPCBox) Ge(box2 *TPCBox) (bool, error) { } // TPCBoxFromEWKB is the portable fromEWKB of MEOS tpcbox_from_wkb. -func TPCBoxFromEWKB(wkb unsafe.Pointer, size uint) (*TPCBox, error) { - return TPCBoxFromWKB(wkb, size) +func TPCBoxFromEWKB(wkb []byte) (*TPCBox, error) { + return TPCBoxFromWKB(wkb) } // TPCBoxFromHexEWKB is the portable fromHexEWKB of MEOS tpcbox_from_hexwkb. diff --git a/types/tpcpatch.go b/types/tpcpatch.go index 172d1e6..bfe4a5c 100644 --- a/types/tpcpatch.go +++ b/types/tpcpatch.go @@ -192,8 +192,8 @@ func (x *TPcpatch) Npoints() (int64, error) { } // TPcpatchFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb. -func TPcpatchFromEWKB(wkb unsafe.Pointer, size uint) (*TPcpatch, error) { - r, err := TemporalFromWKB(wkb, size) +func TPcpatchFromEWKB(wkb []byte) (*TPcpatch, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -237,8 +237,8 @@ func TPcpatchFromText(str string) (*TPcpatch, error) { } // TPcpatchFromWKB is the portable fromWKB of MEOS temporal_from_wkb. -func TPcpatchFromWKB(wkb unsafe.Pointer, size uint) (*TPcpatch, error) { - r, err := TemporalFromWKB(wkb, size) +func TPcpatchFromWKB(wkb []byte) (*TPcpatch, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/tpcpoint.go b/types/tpcpoint.go index 0a277ad..d1a8c49 100644 --- a/types/tpcpoint.go +++ b/types/tpcpoint.go @@ -165,8 +165,8 @@ func (x *TPcpoint) Pcid() (uint32, error) { } // TPcpointFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb. -func TPcpointFromEWKB(wkb unsafe.Pointer, size uint) (*TPcpoint, error) { - r, err := TemporalFromWKB(wkb, size) +func TPcpointFromEWKB(wkb []byte) (*TPcpoint, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -210,8 +210,8 @@ func TPcpointFromText(str string) (*TPcpoint, error) { } // TPcpointFromWKB is the portable fromWKB of MEOS temporal_from_wkb. -func TPcpointFromWKB(wkb unsafe.Pointer, size uint) (*TPcpoint, error) { - r, err := TemporalFromWKB(wkb, size) +func TPcpointFromWKB(wkb []byte) (*TPcpoint, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/tpose.go b/types/tpose.go index dafd85e..8ded44a 100644 --- a/types/tpose.go +++ b/types/tpose.go @@ -399,8 +399,8 @@ func (x *TPose) MinusStbox(box *STBox, border_inc bool) (*Temporal, error) { } // TPoseFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb. -func TPoseFromEWKB(wkb unsafe.Pointer, size uint) (*TPose, error) { - r, err := TemporalFromWKB(wkb, size) +func TPoseFromEWKB(wkb []byte) (*TPose, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -444,8 +444,8 @@ func TPoseFromText(str string) (*TPose, error) { } // TPoseFromWKB is the portable fromWKB of MEOS temporal_from_wkb. -func TPoseFromWKB(wkb unsafe.Pointer, size uint) (*TPose, error) { - r, err := TemporalFromWKB(wkb, size) +func TPoseFromWKB(wkb []byte) (*TPose, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/tposechain.go b/types/tposechain.go index ac761e0..5d265c0 100644 --- a/types/tposechain.go +++ b/types/tposechain.go @@ -195,8 +195,8 @@ func (x *TPoseChain) MinusValue(pc unsafe.Pointer) (*Temporal, error) { } // TPoseChainFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb. -func TPoseChainFromEWKB(wkb unsafe.Pointer, size uint) (*TPoseChain, error) { - r, err := TemporalFromWKB(wkb, size) +func TPoseChainFromEWKB(wkb []byte) (*TPoseChain, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -240,8 +240,8 @@ func TPoseChainFromText(str string) (*TPoseChain, error) { } // TPoseChainFromWKB is the portable fromWKB of MEOS temporal_from_wkb. -func TPoseChainFromWKB(wkb unsafe.Pointer, size uint) (*TPoseChain, error) { - r, err := TemporalFromWKB(wkb, size) +func TPoseChainFromWKB(wkb []byte) (*TPoseChain, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/tquadbin.go b/types/tquadbin.go index d4dc288..6698692 100644 --- a/types/tquadbin.go +++ b/types/tquadbin.go @@ -183,8 +183,8 @@ func (x *TQuadbin) GridDistance(dest *Temporal) (*Temporal, error) { } // TQuadbinFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb. -func TQuadbinFromEWKB(wkb unsafe.Pointer, size uint) (*TQuadbin, error) { - r, err := TemporalFromWKB(wkb, size) +func TQuadbinFromEWKB(wkb []byte) (*TQuadbin, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -228,8 +228,8 @@ func TQuadbinFromText(str string) (*TQuadbin, error) { } // TQuadbinFromWKB is the portable fromWKB of MEOS temporal_from_wkb. -func TQuadbinFromWKB(wkb unsafe.Pointer, size uint) (*TQuadbin, error) { - r, err := TemporalFromWKB(wkb, size) +func TQuadbinFromWKB(wkb []byte) (*TQuadbin, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/trgeometry.go b/types/trgeometry.go index 71d5a0c..cabe565 100644 --- a/types/trgeometry.go +++ b/types/trgeometry.go @@ -723,8 +723,8 @@ func (x *TRGeometry) MinusTstzspanset(ss *SpanSet) (*Temporal, error) { } // TRGeometryFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb. -func TRGeometryFromEWKB(wkb unsafe.Pointer, size uint) (*TRGeometry, error) { - r, err := TemporalFromWKB(wkb, size) +func TRGeometryFromEWKB(wkb []byte) (*TRGeometry, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -768,8 +768,8 @@ func TRGeometryFromText(str string) (*TRGeometry, error) { } // TRGeometryFromWKB is the portable fromWKB of MEOS temporal_from_wkb. -func TRGeometryFromWKB(wkb unsafe.Pointer, size uint) (*TRGeometry, error) { - r, err := TemporalFromWKB(wkb, size) +func TRGeometryFromWKB(wkb []byte) (*TRGeometry, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/ts2cell.go b/types/ts2cell.go index 10281a8..263cd5f 100644 --- a/types/ts2cell.go +++ b/types/ts2cell.go @@ -183,8 +183,8 @@ func (x *TS2Cell) GridDistance(dest *Temporal) (*Temporal, error) { } // TS2CellFromEWKB is the portable fromEWKB of MEOS temporal_from_wkb. -func TS2CellFromEWKB(wkb unsafe.Pointer, size uint) (*TS2Cell, error) { - r, err := TemporalFromWKB(wkb, size) +func TS2CellFromEWKB(wkb []byte) (*TS2Cell, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } @@ -228,8 +228,8 @@ func TS2CellFromText(str string) (*TS2Cell, error) { } // TS2CellFromWKB is the portable fromWKB of MEOS temporal_from_wkb. -func TS2CellFromWKB(wkb unsafe.Pointer, size uint) (*TS2Cell, error) { - r, err := TemporalFromWKB(wkb, size) +func TS2CellFromWKB(wkb []byte) (*TS2Cell, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/tspatial.go b/types/tspatial.go index ef73cbf..248a879 100644 --- a/types/tspatial.go +++ b/types/tspatial.go @@ -35,12 +35,13 @@ func (x *TSpatial) Out(maxdd int) (string, error) { } // AsEWKB is MEOS tspatial_as_ewkb. -func (x *TSpatial) AsEWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { - _r0, _err := functions.TspatialAsEWKB(functions.TemporalFromPointer(x.Pointer()), variant, size_out) +func (x *TSpatial) AsEWKB(variant uint8) ([]byte, error) { + var _size uint64 + _r0, _err := functions.TspatialAsEWKB(functions.TemporalFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return nil, _err } - return _r0, nil + return functions.TakeBytes(_r0, _size), nil } // AsEWKT is MEOS tspatial_as_ewkt. @@ -53,8 +54,9 @@ func (x *TSpatial) AsEWKT(maxdd int) (string, error) { } // AsHexEWKB is MEOS tspatial_as_hexewkb. -func (x *TSpatial) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { - _r0, _err := functions.TspatialAsHexewkb(functions.TemporalFromPointer(x.Pointer()), variant, size_out) +func (x *TSpatial) AsHexEWKB(variant uint8) (string, error) { + var _size uint64 + _r0, _err := functions.TspatialAsHexewkb(functions.TemporalFromPointer(x.Pointer()), variant, unsafe.Pointer(&_size)) if _err != nil { return "", _err } diff --git a/types/tstzset.go b/types/tstzset.go index 60830d7..3ff3bd2 100644 --- a/types/tstzset.go +++ b/types/tstzset.go @@ -131,8 +131,8 @@ func TsTzSetFromText(str string) (*TsTzSet, error) { } // TsTzSetFromWKB is the portable fromWKB of MEOS set_from_wkb. -func TsTzSetFromWKB(wkb unsafe.Pointer, size uint) (*TsTzSet, error) { - r, err := SetFromWKB(wkb, size) +func TsTzSetFromWKB(wkb []byte) (*TsTzSet, error) { + r, err := SetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/tstzspan.go b/types/tstzspan.go index d870bba..4631ca1 100644 --- a/types/tstzspan.go +++ b/types/tstzspan.go @@ -110,8 +110,8 @@ func TsTzSpanFromText(str string) (*TsTzSpan, error) { } // TsTzSpanFromWKB is the portable fromWKB of MEOS span_from_wkb. -func TsTzSpanFromWKB(wkb unsafe.Pointer, size uint) (*TsTzSpan, error) { - r, err := SpanFromWKB(wkb, size) +func TsTzSpanFromWKB(wkb []byte) (*TsTzSpan, error) { + r, err := SpanFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/tstzspanset.go b/types/tstzspanset.go index 5bffeae..575912a 100644 --- a/types/tstzspanset.go +++ b/types/tstzspanset.go @@ -149,8 +149,8 @@ func TsTzSpanSetFromText(str string) (*TsTzSpanSet, error) { } // TsTzSpanSetFromWKB is the portable fromWKB of MEOS spanset_from_wkb. -func TsTzSpanSetFromWKB(wkb unsafe.Pointer, size uint) (*TsTzSpanSet, error) { - r, err := SpanSetFromWKB(wkb, size) +func TsTzSpanSetFromWKB(wkb []byte) (*TsTzSpanSet, error) { + r, err := SpanSetFromWKB(wkb) if err != nil || r == nil { return nil, err } diff --git a/types/ttext.go b/types/ttext.go index 2a81515..3b0b659 100644 --- a/types/ttext.go +++ b/types/ttext.go @@ -224,8 +224,8 @@ func TTextFromText(str string) (*TText, error) { } // TTextFromWKB is the portable fromWKB of MEOS temporal_from_wkb. -func TTextFromWKB(wkb unsafe.Pointer, size uint) (*TText, error) { - r, err := TemporalFromWKB(wkb, size) +func TTextFromWKB(wkb []byte) (*TText, error) { + r, err := TemporalFromWKB(wkb) if err != nil || r == nil { return nil, err }