From 8e01cb38f68ca85391dfe3cef74a5decc820db01 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 3 Sep 2026 18:16:48 +0200 Subject: [PATCH 1/2] Refresh the committed functions snapshot against the MEOS surface Regenerating from a catalog derived at current master moves two wrappers, both of them MEOS's own movement rather than a generator change: * `tbigint_values` takes `int *` where the snapshot recorded `int32_t *`, so the cast becomes `(*C.int)`; * `geom_azimuth` joins the geo surface, and it carries a folded out-parameter, so the wrapper answers `(bool, float64, error)`. The committed snapshot is what CI compiles before it regenerates, so it has to be the projection of the surface that exists today rather than of the one that existed when it was last written. --- functions/meos_meos.go | 2 +- functions/meos_meos_geo.go | 11 +++++++++++ 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/functions/meos_meos.go b/functions/meos_meos.go index 33e4052..0ce5f79 100644 --- a/functions/meos_meos.go +++ b/functions/meos_meos.go @@ -10307,7 +10307,7 @@ func TintValues(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err // TbigintValues wraps MEOS C function tbigint_values. func TbigintValues(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { C.meos_errno_reset() - _cret := C.tbigint_values(temp._inner, (*C.int32)(unsafe.Pointer(count))) + _cret := C.tbigint_values(temp._inner, (*C.int)(unsafe.Pointer(count))) if _err = meosError(); _err != nil { return } diff --git a/functions/meos_meos_geo.go b/functions/meos_meos_geo.go index 904bcbc..9e3b7ca 100644 --- a/functions/meos_meos_geo.go +++ b/functions/meos_meos_geo.go @@ -491,6 +491,17 @@ func GeomAzimuth(gs1 *Geom, gs2 *Geom) (_r0 bool, _r1 float64, _err error) { } +// GeomArea wraps MEOS C function geom_area. +func GeomArea(gs *Geom) (_r0 float64, _err error) { + C.meos_errno_reset() + _cret := C.geom_area(gs._inner) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil +} + + // GeomLength wraps MEOS C function geom_length. func GeomLength(gs *Geom) (_r0 float64, _err error) { C.meos_errno_reset() From 454014a4ab3907c2e66a81206f1c2387a6189a66 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 3 Sep 2026 18:17:36 +0200 Subject: [PATCH 2/2] Generate the object layer from the catalog's object model GoMEOS ships a generated flat FFI layer and a hand-written idiomatic one, so every class, method and conversion above the wrappers is written and maintained by hand. The catalog already states that layer: `objectModel.lattice` carries the temporal tree, `companions` the Box, Collection and Value hierarchies, and `classes..methods` assigns each public MEOS function to the class it is a method of, under its canonical camelCase `ooName`. MEOS.NET projects the same model through its own `tools/objectgen.py`; this is the Go projection of it. Go spells inheritance as embedding, so `TBool` embeds `TAlpha` embeds `Temporal` and a parent's methods are promoted. Each instance carries the MEOS pointer, and the two packages exchange it as an `unsafe.Pointer`, because cgo types are package-scoped and `*C.Temporal` in `functions` is not the same Go type as one declared here. THE SIGNATURES COME FROM `codegen.SIGNATURES`, so the two generators cannot disagree. MEOS declares `bool tbool_value_at_timestamptz(..., bool *value)` -- four parameters, one of them written through -- while the wrapper takes three and answers two values. Reading the C signature would reconstruct a shape the wrapper does not have. The table is filled by RUNNING the flat generator, so which functions have a wrapper is decided in one place and this file holds no second copy of what that generator skips. ABSENCE STAYS AN OPTIONAL, in the shape this repository already merged: where MEOS answers a flag and writes the value out, the method answers `(value, ok, error)` with `ok` false leaving the value at its zero and the error nil. `TBool.ValueAtTimestamptz` is generated to exactly what #21 hand-wrote. MEASURED against a catalog derived at current master: 115 classes, 1256 methods, 105 deferred, each deferral naming the parameter or result that stopped it rather than being dropped silently. `go build ./types ./functions` and `go vet ./types` both exit 0, `gofmt -l` reports 0 of 116 files, and a second run of the generator reproduces the tree byte for byte. The layer is ADDITIVE: the root package is untouched, so no published name moves. --- tools/objectgen.py | 437 +++++++++++++++++++++ types/bigintset.go | 99 +++++ types/bigintspan.go | 123 ++++++ types/bigintspanset.go | 87 +++++ types/box.go | 22 ++ types/cbuffer.go | 321 ++++++++++++++++ types/cbufferset.go | 90 +++++ types/collection.go | 22 ++ types/dateset.go | 108 ++++++ types/datespan.go | 87 +++++ types/datespanset.go | 126 +++++++ types/floatset.go | 144 +++++++ types/floatspan.go | 168 +++++++++ types/floatspanset.go | 141 +++++++ types/geo.go | 402 ++++++++++++++++++++ types/geography.go | 114 ++++++ types/geogset.go | 33 ++ types/geometry.go | 360 ++++++++++++++++++ types/geomset.go | 81 ++++ types/intset.go | 108 ++++++ types/intspan.go | 123 ++++++ types/intspanset.go | 96 +++++ types/jsonb.go | 429 +++++++++++++++++++++ types/jsonpath.go | 51 +++ types/meos.go | 23 ++ types/meosarray.go | 76 ++++ types/npoint.go | 285 ++++++++++++++ types/npointset.go | 99 +++++ types/nsegment.go | 177 +++++++++ types/pcpatch.go | 177 +++++++++ types/pcpoint.go | 168 +++++++++ types/pcschema.go | 102 +++++ types/pose.go | 465 +++++++++++++++++++++++ types/posechain.go | 375 ++++++++++++++++++ types/poseset.go | 90 +++++ types/raquet.go | 22 ++ types/rtree.go | 164 ++++++++ types/rtreenncursor.go | 47 +++ types/set.go | 222 +++++++++++ types/span.go | 186 +++++++++ types/spanset.go | 267 +++++++++++++ types/spnncursor.go | 47 +++ types/sptree.go | 92 +++++ types/stbox.go | 477 +++++++++++++++++++++++ types/talpha.go | 24 ++ types/tbigint.go | 192 ++++++++++ types/tbigintinst.go | 33 ++ types/tbigintseq.go | 42 +++ types/tbigintseqset.go | 33 ++ types/tbool.go | 147 ++++++++ types/tboolinst.go | 33 ++ types/tboolseq.go | 42 +++ types/tboolseqset.go | 33 ++ types/tbox.go | 336 +++++++++++++++++ types/tcbuffer.go | 228 +++++++++++ types/tcbufferinst.go | 33 ++ types/tcbufferseq.go | 42 +++ types/tcbufferseqset.go | 33 ++ types/temporal.go | 776 ++++++++++++++++++++++++++++++++++++++ types/text.go | 78 ++++ types/textset.go | 117 ++++++ types/tfloat.go | 309 +++++++++++++++ types/tfloatinst.go | 33 ++ types/tfloatseq.go | 42 +++ types/tfloatseqset.go | 33 ++ types/tgeo.go | 212 +++++++++++ types/tgeogpoint.go | 69 ++++ types/tgeogpointinst.go | 22 ++ types/tgeogpointseq.go | 22 ++ types/tgeogpointseqset.go | 22 ++ types/tgeography.go | 60 +++ types/tgeographyinst.go | 22 ++ types/tgeographyseq.go | 22 ++ types/tgeographyseqset.go | 22 ++ types/tgeometry.go | 69 ++++ types/tgeometryinst.go | 22 ++ types/tgeometryseq.go | 22 ++ types/tgeometryseqset.go | 22 ++ types/tgeompoint.go | 69 ++++ types/tgeompointinst.go | 22 ++ types/tgeompointseq.go | 22 ++ types/tgeompointseqset.go | 22 ++ types/tinstant.go | 22 ++ types/tint.go | 219 +++++++++++ types/tintinst.go | 33 ++ types/tintseq.go | 42 +++ types/tintseqset.go | 33 ++ types/tjsonb.go | 354 +++++++++++++++++ types/tjsonbinst.go | 33 ++ types/tjsonbseq.go | 42 +++ types/tjsonbseqset.go | 33 ++ types/tnpoint.go | 264 +++++++++++++ types/tnpointinst.go | 33 ++ types/tnpointseq.go | 42 +++ types/tnpointseqset.go | 33 ++ types/tnumber.go | 188 +++++++++ types/tpcbox.go | 324 ++++++++++++++++ types/tpoint.go | 221 +++++++++++ types/tpose.go | 327 ++++++++++++++++ types/tposeinst.go | 33 ++ types/tposeseq.go | 42 +++ types/tposeseqset.go | 33 ++ types/trgeometry.go | 684 +++++++++++++++++++++++++++++++++ types/trgeometryinst.go | 33 ++ types/trgeometryseq.go | 33 ++ types/trgeometryseqset.go | 33 ++ types/tsequence.go | 33 ++ types/tsequenceset.go | 33 ++ types/tspatial.go | 98 +++++ types/tstzset.go | 108 ++++++ types/tstzspan.go | 87 +++++ types/tstzspanset.go | 126 +++++++ types/ttext.go | 183 +++++++++ types/ttextinst.go | 33 ++ types/ttextseq.go | 42 +++ types/ttextseqset.go | 33 ++ types/value.go | 22 ++ 117 files changed, 14647 insertions(+) create mode 100644 tools/objectgen.py create mode 100644 types/bigintset.go create mode 100644 types/bigintspan.go create mode 100644 types/bigintspanset.go create mode 100644 types/box.go create mode 100644 types/cbuffer.go create mode 100644 types/cbufferset.go create mode 100644 types/collection.go create mode 100644 types/dateset.go create mode 100644 types/datespan.go create mode 100644 types/datespanset.go create mode 100644 types/floatset.go create mode 100644 types/floatspan.go create mode 100644 types/floatspanset.go create mode 100644 types/geo.go create mode 100644 types/geography.go create mode 100644 types/geogset.go create mode 100644 types/geometry.go create mode 100644 types/geomset.go create mode 100644 types/intset.go create mode 100644 types/intspan.go create mode 100644 types/intspanset.go create mode 100644 types/jsonb.go create mode 100644 types/jsonpath.go create mode 100644 types/meos.go create mode 100644 types/meosarray.go create mode 100644 types/npoint.go create mode 100644 types/npointset.go create mode 100644 types/nsegment.go create mode 100644 types/pcpatch.go create mode 100644 types/pcpoint.go create mode 100644 types/pcschema.go create mode 100644 types/pose.go create mode 100644 types/posechain.go create mode 100644 types/poseset.go create mode 100644 types/raquet.go create mode 100644 types/rtree.go create mode 100644 types/rtreenncursor.go create mode 100644 types/set.go create mode 100644 types/span.go create mode 100644 types/spanset.go create mode 100644 types/spnncursor.go create mode 100644 types/sptree.go create mode 100644 types/stbox.go create mode 100644 types/talpha.go create mode 100644 types/tbigint.go create mode 100644 types/tbigintinst.go create mode 100644 types/tbigintseq.go create mode 100644 types/tbigintseqset.go create mode 100644 types/tbool.go create mode 100644 types/tboolinst.go create mode 100644 types/tboolseq.go create mode 100644 types/tboolseqset.go create mode 100644 types/tbox.go create mode 100644 types/tcbuffer.go create mode 100644 types/tcbufferinst.go create mode 100644 types/tcbufferseq.go create mode 100644 types/tcbufferseqset.go create mode 100644 types/temporal.go create mode 100644 types/text.go create mode 100644 types/textset.go create mode 100644 types/tfloat.go create mode 100644 types/tfloatinst.go create mode 100644 types/tfloatseq.go create mode 100644 types/tfloatseqset.go create mode 100644 types/tgeo.go create mode 100644 types/tgeogpoint.go create mode 100644 types/tgeogpointinst.go create mode 100644 types/tgeogpointseq.go create mode 100644 types/tgeogpointseqset.go create mode 100644 types/tgeography.go create mode 100644 types/tgeographyinst.go create mode 100644 types/tgeographyseq.go create mode 100644 types/tgeographyseqset.go create mode 100644 types/tgeometry.go create mode 100644 types/tgeometryinst.go create mode 100644 types/tgeometryseq.go create mode 100644 types/tgeometryseqset.go create mode 100644 types/tgeompoint.go create mode 100644 types/tgeompointinst.go create mode 100644 types/tgeompointseq.go create mode 100644 types/tgeompointseqset.go create mode 100644 types/tinstant.go create mode 100644 types/tint.go create mode 100644 types/tintinst.go create mode 100644 types/tintseq.go create mode 100644 types/tintseqset.go create mode 100644 types/tjsonb.go create mode 100644 types/tjsonbinst.go create mode 100644 types/tjsonbseq.go create mode 100644 types/tjsonbseqset.go create mode 100644 types/tnpoint.go create mode 100644 types/tnpointinst.go create mode 100644 types/tnpointseq.go create mode 100644 types/tnpointseqset.go create mode 100644 types/tnumber.go create mode 100644 types/tpcbox.go create mode 100644 types/tpoint.go create mode 100644 types/tpose.go create mode 100644 types/tposeinst.go create mode 100644 types/tposeseq.go create mode 100644 types/tposeseqset.go create mode 100644 types/trgeometry.go create mode 100644 types/trgeometryinst.go create mode 100644 types/trgeometryseq.go create mode 100644 types/trgeometryseqset.go create mode 100644 types/tsequence.go create mode 100644 types/tsequenceset.go create mode 100644 types/tspatial.go create mode 100644 types/tstzset.go create mode 100644 types/tstzspan.go create mode 100644 types/tstzspanset.go create mode 100644 types/ttext.go create mode 100644 types/ttextinst.go create mode 100644 types/ttextseq.go create mode 100644 types/ttextseqset.go create mode 100644 types/value.go diff --git a/tools/objectgen.py b/tools/objectgen.py new file mode 100644 index 0000000..06ff37b --- /dev/null +++ b/tools/objectgen.py @@ -0,0 +1,437 @@ +#!/usr/bin/env python3 +# BINDING-HEADER-PARSE-OK: this generator reads only the meos-idl.json catalog, +# never a C header; the catalog is the binding's single source of truth. +"""Generate the GoMEOS object layer from MEOS-API's meos-idl.json. + +The catalog's ``objectModel`` is the ecosystem-wide statement of the class hierarchy +implicit in MEOS: ``lattice`` carries the temporal tree, ``companions`` the Box, +Collection and Value hierarchies, and ``classes..methods`` assigns every public +MEOS function to the class it is a method of, under its canonical camelCase ``ooName``. +This projects that model onto Go -- one type per model class, the model's parent edge +spelled as struct embedding, and one method per assigned function delegating to the +wrapper ``codegen.py`` emits for the same function. + +THE WRAPPER SIGNATURES COME FROM ``codegen.SIGNATURES``, never from the raw C parameter +list, so the two generators cannot disagree about a folded out-parameter: MEOS declares +``bool tbool_value_at_timestamptz(..., bool *value)`` and the emitted wrapper takes three +arguments and answers two values, which no C signature states. That table is filled by +RUNNING the flat generator, so which functions have a wrapper is decided in exactly one +place; this file holds no second copy of what that generator skips. + +Go spells inheritance as embedding, so ``TBool`` embeds ``TAlpha`` embeds ``Temporal`` +and a parent's methods are promoted. Every instance is a handle to the MEOS value, and +the two packages exchange one across ``unsafe.Pointer`` -- cgo types are package-scoped, +so ``*C.Temporal`` in ``functions`` and here are different Go types and the pointer is +the only shared currency. + +Usage: + python3 tools/objectgen.py path/to/meos-idl.json [--report] + +Regenerates functions/ (through codegen) and writes types/*.go, replacing that directory. +""" + +from __future__ import annotations + +import argparse +import json +import shutil +import sys +from collections import defaultdict +from pathlib import Path + +import codegen + +PACKAGE = "types" +FUNCTIONS_IMPORT = "github.com/MobilityDB/GoMEOS/functions" + +# The C structs that carry the Temporal header and are discriminated by its ``subtype`` +# field. A pointer to any of them is a Temporal at the surface, exactly as MEOS.NET's +# object layer resolves them, because the concrete class is the product leaf x subtype +# and the leaf family carries by far the larger surface. +TEMPORAL_STRUCTS = ("Temporal", "TInstant", "TSequence", "TSequenceSet") + +GO_KEYWORDS = { + "break", "case", "chan", "const", "continue", "default", "defer", "else", + "fallthrough", "for", "func", "go", "goto", "if", "import", "interface", "map", + "package", "range", "return", "select", "struct", "switch", "type", "var", +} + +# Acronym runs kept upper case so a Go name reads the way the catalog's own camelCase +# name does: ``asMFJSON`` becomes ``AsMFJSON`` rather than ``AsMfjson``. +ACRONYMS = {"mfjson", "geojson", "wkb", "wkt", "ewkb", "ewkt", "hexwkb", "hexewkb", + "srid", "json", "jsonb", "mvt", "gml", "kml", "de9im", "id", "url"} + + +def pascal(name: str) -> str: + """The Go exported spelling of a catalog camelCase ``ooName``.""" + out, word = [], [] + + def flush(): + if not word: + return + w = "".join(word) + out.append(w.upper() if w.lower() in ACRONYMS else w[:1].upper() + w[1:]) + word.clear() + + for ch in name: + if ch in "_-": + flush() + continue + if ch.isupper() and word: + flush() + word.append(ch) + flush() + return "".join(out) or name + + +def ident(name: str) -> str: + """A Go parameter name, kept clear of the keywords.""" + return name + "_" if name in GO_KEYWORDS else name + + +def zero(go_type: str) -> str: + """The zero value of a Go type, for the error and absent returns.""" + if go_type.startswith("*") or go_type.startswith("[]") or go_type == "unsafe.Pointer": + return "nil" + if go_type == "string": + return '""' + if go_type == "bool": + return "false" + return "0" + + +class Model: + """The class hierarchy the catalog defines, indexed for emission.""" + + def __init__(self, idl: dict): + self.idl = idl + self.om = idl["objectModel"] + self.functions = {f["name"]: f for f in idl["functions"]} + self.parent: dict[str, str | None] = {} + self.ctype: dict[str, str] = {} + self.wrap_root: dict[str, str] = {} + self._build() + + def _build(self) -> None: + for name, node in self.om["lattice"].items(): + self.parent[name] = node["parent"] + + # The template subtypes are classes of their own, under the root. + for value in self.om["axes"]["subtype"]["values"]: + cls = value.get("class") + if cls: + self.parent[cls] = "Temporal" + + for family in [k for k in self.om["companions"] if not k.startswith("_")]: + for name, node in self.om["companions"][family]["nodes"].items(): + if name.startswith("_"): + continue + self.parent[name] = node["parent"] + + # What a class's instances point to is the catalog's to say, so every class + # takes the cType the model derives from MEOS's own signatures. A binding + # holding that map itself cannot reach a class the model gains. + for name, spec in self.om["classes"].items(): + if spec.get("cType"): + self.ctype[name] = spec["cType"] + self.parent.setdefault(name, None) + + # A pointer to a C struct is wrapped in the SHALLOWEST class carrying it, so a + # GSERIALIZED * is a Geo and its Geometry and Geography leaves stay distinct + # classes under it, exactly as a Set * is a Set. + for name, ct in self.ctype.items(): + best = self.wrap_root.get(ct) + if best is None or self.depth(name) < self.depth(best): + self.wrap_root[ct] = name + + def depth(self, cls: str) -> int: + d, seen = 0, {cls} + p = self.parent.get(cls) + while p and p not in seen: + seen.add(p) + d += 1 + p = self.parent.get(p) + return d + + def ancestors(self, cls: str) -> list[str]: + out, seen = [], {cls} + p = self.parent.get(cls) + while p and p not in seen: + out.append(p) + seen.add(p) + p = self.parent.get(p) + return out + + def classes(self) -> list[str]: + """Every type the layer declares, superclass included. + + A companion ROOT -- Box, Collection, Value -- is a parent edge in the model + and carries no ``classes`` entry of its own, so emitting only what ``classes`` + names leaves each child embedding a type nothing declares. The set to emit is + therefore the classes UNION everything named as a parent. + """ + named = set(self.om["classes"]) + parents = {p for p in self.parent.values() if p} + return sorted(named | parents) + + def class_for_ctype(self, struct: str) -> str | None: + """The class a single pointer to this C struct is wrapped in.""" + if struct in TEMPORAL_STRUCTS: + return "Temporal" + return self.wrap_root.get(struct) + + +class Generator: + def __init__(self, model: Model): + self.m = model + self.deferred: dict[str, list[str]] = defaultdict(list) + self.emitted = 0 + # The Go handle each wrapper struct reaches the flat layer as, read from the + # flat generator rather than restated: WRAPPER_TYPES is what decides it. Its + # value carries the star and need not echo the struct -- GSERIALIZED reaches + # Go as `*Geom` -- so the handle NAME is that value without the star, and it + # is what `functions.FromPointer` is called. + self.handle_of = {c: go.lstrip("*") for c, (go, _) in codegen.WRAPPER_TYPES.items()} + self.struct_of = {go: c for c, (go, _) in codegen.WRAPPER_TYPES.items()} + self.scalars = set(t.go_type for t in codegen.TYPE_MAP.values()) + + # -- marshalling ------------------------------------------------------ + + def class_of_handle(self, go_type: str) -> str | None: + """The model class behind a wrapper's ``*Handle`` Go type, if there is one.""" + if not go_type.startswith("*"): + return None + struct = self.struct_of.get(go_type) + return self.m.class_for_ctype(struct) if struct else None + + def passthrough(self, go_type: str) -> bool: + return go_type in self.scalars or go_type in ("string", "bool", "unsafe.Pointer") + + def qualify(self, go_type: str) -> str: + """A passthrough type as this package must spell it. + + The flat generator declares the catalog's enums and named scalars as Go types + of its OWN package -- `Interpolation`, `NullHandleType`, `MeosType` -- so a + method carrying one names it `functions.X` here. Go's predeclared types are all + lower case, which is the discriminator, so a new enum needs no list entry. + """ + prefix, base = "", go_type + while base.startswith("[]"): + prefix, base = prefix + "[]", base[2:] + if base.startswith("*"): + prefix, base = prefix + "*", base[1:] + if base[:1].isupper(): + return f"{prefix}functions.{base}" + return go_type + + def map_param(self, go_type: str, name: str) -> tuple[str, str] | None: + """``(go type in this layer, the expression handed to the wrapper)``.""" + cls = self.class_of_handle(go_type) + if cls: + # THE DECLARED TYPE AND THE HANDLE ARE NOT THE SAME QUESTION. The surface + # takes the CLASS a pointer is wrapped in -- TInstant, TSequence and + # TSequenceSet all surface as Temporal -- while the wrapper wants the + # handle IT declares, so the conversion reads the wrapper's own struct. + # Only the pointer crosses, so the two need not agree. + handle = self.handle_of.get(self.struct_of.get(go_type, "")) + if handle is None: + return None + return (f"*{cls}", f"functions.{handle}FromPointer({name}.Pointer())") + if self.passthrough(go_type): + return (self.qualify(go_type), name) + return None + + def map_return(self, go_type: str, expr: str) -> tuple[str, str] | None: + """``(go type in this layer, the expression producing it)``.""" + cls = self.class_of_handle(go_type) + if cls: + return (f"*{cls}", f"{cls}FromPointer({expr}.Pointer())") + if self.passthrough(go_type): + return (self.qualify(go_type), expr) + return None + + # -- emission --------------------------------------------------------- + + def method_for(self, cls: str, entry: dict) -> str | None: + oo = entry["ooName"] + fname = entry["function"] + sig = codegen.SIGNATURES.get(fname) + if sig is None: + self.deferred[cls].append(f"{oo}: {fname} has no emitted wrapper") + return None + f = self.m.functions.get(fname) + if f is None: + self.deferred[cls].append(f"{oo}: no catalog function {fname}") + return None + + # A first parameter that is this class (or an ancestor of it) makes the + # function a METHOD ON the value; anything else is a plain function of the + # class, which is how Go spells a static. + family = {cls, *self.m.ancestors(cls)} + params = list(sig.params) + recv = None + if params and self.class_of_handle(params[0][1]) in family: + recv = params.pop(0) + + args, decl = [], [] + for pname, ptype in params: + mapped = self.map_param(ptype, ident(pname)) + if mapped is None: + self.deferred[cls].append(f"{oo}: parameter {pname} is {ptype}") + return None + gotype, expr = mapped + decl.append(f"{ident(pname)} {gotype}") + args.append(expr) + + if recv is not None: + handle = self.handle_of.get(self.struct_of.get(recv[1], "")) + if handle is None: + self.deferred[cls].append(f"{oo}: receiver {recv[1]} has no handle") + return None + args.insert(0, f"functions.{handle}FromPointer(x.Pointer())") + + name = pascal(oo) if recv is not None else cls + pascal(oo) + + # THE OUT-PARAMETER FOLD, and the shape is the repository's own: MEOS answers + # a bool saying whether a value is there and writes the value out, so the + # wrapper returns (found, value, error) and the method answers (value, ok, + # error) -- absence is an optional result, never an error. + folded = (len(sig.returns) == 2 and sig.returns[0] == "bool" + and f["returnType"]["c"].replace("const ", "").strip() == "bool") + + rets, body = [], [] + call = f"functions.{sig.go_name}({', '.join(args)})" + + if not sig.returns: + body.append(f"\treturn {call}") + elif folded: + mapped = self.map_return(sig.returns[1], "_value") + if mapped is None: + self.deferred[cls].append(f"{oo}: result {sig.returns[1]}") + return None + gotype, expr = mapped + rets = [gotype, "bool"] + body.append(f"\t_found, _value, _err := {call}") + body.append(f"\tif _err != nil {{\n\t\treturn {zero(gotype)}, false, _err\n\t}}") + body.append(f"\tif !_found {{\n\t\treturn {zero(gotype)}, false, nil\n\t}}") + body.append(f"\treturn {expr}, true, nil") + else: + names = [f"_r{i}" for i in range(len(sig.returns))] + outs = [] + for i, rt in enumerate(sig.returns): + mapped = self.map_return(rt, names[i]) + if mapped is None: + self.deferred[cls].append(f"{oo}: result {rt}") + return None + rets.append(mapped[0]) + outs.append(mapped[1]) + body.append(f"\t{', '.join(names)}, _err := {call}") + body.append("\tif _err != nil {\n\t\treturn " + + ", ".join(zero(r) for r in rets) + ", _err\n\t}") + body.append(f"\treturn {', '.join(outs)}, nil") + + result = f"({', '.join(rets + ['error'])})" if rets else "error" + head = (f"func (x *{cls}) {name}({', '.join(decl)}) {result} {{" + if recv is not None else + f"func {name}({', '.join(decl)}) {result} {{") + self.emitted += 1 + return f"// {name} is MEOS {fname}.\n{head}\n" + "\n".join(body) + "\n}\n" + + def emit_class(self, cls: str) -> str: + spec = self.m.om["classes"].get(cls) or {"methods": []} + parent = self.m.parent.get(cls) + + methods, seen = [], set() + for entry in spec["methods"]: + if entry.get("ooExclude"): + continue + code = self.method_for(cls, entry) + if code is None: + continue + head = code.split("\n")[1] + if head in seen: + continue + seen.add(head) + methods.append(code) + + uses_functions = any("functions." in m for m in methods) + imports = ['\t"unsafe"'] + if uses_functions: + imports.append(f'\n\t"{FUNCTIONS_IMPORT}"') + + out = [f"package {PACKAGE}\n", + "// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT.\n", + "import (\n" + "\n".join(imports) + "\n)\n"] + + doc = (self.m.om["lattice"].get(cls) or {}).get("doc") or "" + if doc: + out.append(f"// {cls} is {doc[0].lower() + doc[1:]}\n") + + out.append(f"type {cls} struct {{\n\t{parent if parent else 'handle'}\n}}\n") + out.append( + f"// {cls}FromPointer wraps a MEOS pointer, answering nil for nil so an\n" + f"// absent MEOS result stays absent rather than becoming a live handle.\n" + f"func {cls}FromPointer(p unsafe.Pointer) *{cls} {{\n" + f"\tif p == nil {{\n\t\treturn nil\n\t}}\n" + f"\tv := &{cls}{{}}\n\tv.ptr = p\n\treturn v\n}}\n") + out.extend(methods) + return "\n".join(out) + + def base_file(self) -> str: + return ( + f"package {PACKAGE}\n\n" + "// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT.\n\n" + 'import "unsafe"\n\n' + "// handle is the MEOS value every class in this package stands for.\n" + "//\n" + "// cgo types are package-scoped, so the *C.Temporal the functions package\n" + "// holds and one declared here would be DIFFERENT Go types. The untyped\n" + "// pointer is the only currency the two packages share, which is why each\n" + "// class carries one and hands it across at every call.\n" + "type handle struct {\n\tptr unsafe.Pointer\n}\n\n" + "// Pointer answers the MEOS value this handle stands for, or nil.\n" + "func (h *handle) Pointer() unsafe.Pointer {\n" + "\tif h == nil {\n\t\treturn nil\n\t}\n\treturn h.ptr\n}\n") + + +def main() -> int: + ap = argparse.ArgumentParser() + ap.add_argument("catalog", type=Path) + ap.add_argument("--report", action="store_true", + help="print what each class deferred and why") + args = ap.parse_args() + + repo = Path(__file__).resolve().parent.parent + + # Fill codegen.SIGNATURES by RUNNING the flat generator, so which functions have a + # wrapper is decided in one place. Re-deriving that here would be a second copy of + # its exclusions, and the two would drift. + stats = codegen.generate(args.catalog, repo / "functions") + print(f"Flat layer: {stats['emitted']} wrappers, " + f"{len(codegen.SIGNATURES)} signatures recorded", file=sys.stderr) + + idl = json.loads(args.catalog.read_text()) + model = Model(idl) + gen = Generator(model) + + out_dir = repo / PACKAGE + if out_dir.exists(): + shutil.rmtree(out_dir) + out_dir.mkdir(parents=True) + (out_dir / "meos.go").write_text(gen.base_file()) + for cls in model.classes(): + (out_dir / f"{cls.lower()}.go").write_text(gen.emit_class(cls)) + + total_deferred = sum(len(v) for v in gen.deferred.values()) + print(f"Object layer: {len(model.classes())} classes, {gen.emitted} methods, " + f"{total_deferred} deferred", file=sys.stderr) + if args.report: + for cls in sorted(gen.deferred, key=lambda c: -len(gen.deferred[c])): + print(f"--- {cls} ({len(gen.deferred[cls])} deferred)", file=sys.stderr) + for reason in gen.deferred[cls]: + print(f" {reason}", file=sys.stderr) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/types/bigintset.go b/types/bigintset.go new file mode 100644 index 0000000..2e40f1a --- /dev/null +++ b/types/bigintset.go @@ -0,0 +1,99 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type BigIntSet struct { + Set +} + +// BigIntSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func BigIntSetFromPointer(p unsafe.Pointer) *BigIntSet { + if p == nil { + return nil + } + v := &BigIntSet{} + v.ptr = p + return v +} + +// BigIntSetIn is MEOS bigintset_in. +func BigIntSetIn(str string) (*Set, error) { + _r0, _err := functions.BigintsetIn(str) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS bigintset_out. +func (x *BigIntSet) Out() (string, error) { + _r0, _err := functions.BigintsetOut(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// BigIntSetMake is MEOS bigintset_make. +func BigIntSetMake(values unsafe.Pointer, count int) (*Set, error) { + _r0, _err := functions.BigintsetMake(values, count) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS bigintset_end_value. +func (x *BigIntSet) EndValue() (int64, error) { + _r0, _err := functions.BigintsetEndValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// StartValue is MEOS bigintset_start_value. +func (x *BigIntSet) StartValue() (int64, error) { + _r0, _err := functions.BigintsetStartValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ValueN is MEOS bigintset_value_n. +func (x *BigIntSet) ValueN(n int) (int64, bool, error) { + _found, _value, _err := functions.BigintsetValueN(functions.SetFromPointer(x.Pointer()), n) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// Values is MEOS bigintset_values. +func (x *BigIntSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.BigintsetValues(functions.SetFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// ShiftScale is MEOS bigintset_shift_scale. +func (x *BigIntSet) ShiftScale(shift int64, width int64, hasshift bool, haswidth bool) (*Set, error) { + _r0, _err := functions.BigintsetShiftScale(functions.SetFromPointer(x.Pointer()), shift, width, hasshift, haswidth) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} diff --git a/types/bigintspan.go b/types/bigintspan.go new file mode 100644 index 0000000..b755290 --- /dev/null +++ b/types/bigintspan.go @@ -0,0 +1,123 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type BigIntSpan struct { + Span +} + +// BigIntSpanFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func BigIntSpanFromPointer(p unsafe.Pointer) *BigIntSpan { + if p == nil { + return nil + } + v := &BigIntSpan{} + v.ptr = p + return v +} + +// Expand is MEOS bigintspan_expand. +func (x *BigIntSpan) Expand(value int64) (*Span, error) { + _r0, _err := functions.BigintspanExpand(functions.SpanFromPointer(x.Pointer()), value) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// BigIntSpanIn is MEOS bigintspan_in. +func BigIntSpanIn(str string) (*Span, error) { + _r0, _err := functions.BigintspanIn(str) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS bigintspan_out. +func (x *BigIntSpan) Out() (string, error) { + _r0, _err := functions.BigintspanOut(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// BigIntSpanMake is MEOS bigintspan_make. +func BigIntSpanMake(lower int64, upper int64, lower_inc bool, upper_inc bool) (*Span, error) { + _r0, _err := functions.BigintspanMake(lower, upper, lower_inc, upper_inc) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// ToIntspan is MEOS bigintspan_to_intspan. +func (x *BigIntSpan) ToIntspan() (*Span, error) { + _r0, _err := functions.BigintspanToIntspan(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// ToFloatspan is MEOS bigintspan_to_floatspan. +func (x *BigIntSpan) ToFloatspan() (*Span, error) { + _r0, _err := functions.BigintspanToFloatspan(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Lower is MEOS bigintspan_lower. +func (x *BigIntSpan) Lower() (int64, error) { + _r0, _err := functions.BigintspanLower(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Upper is MEOS bigintspan_upper. +func (x *BigIntSpan) Upper() (int64, error) { + _r0, _err := functions.BigintspanUpper(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Width is MEOS bigintspan_width. +func (x *BigIntSpan) Width() (int64, error) { + _r0, _err := functions.BigintspanWidth(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ShiftScale is MEOS bigintspan_shift_scale. +func (x *BigIntSpan) ShiftScale(shift int64, width int64, hasshift bool, haswidth bool) (*Span, error) { + _r0, _err := functions.BigintspanShiftScale(functions.SpanFromPointer(x.Pointer()), shift, width, hasshift, haswidth) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Bins is MEOS bigintspan_bins. +func (x *BigIntSpan) Bins(vsize int64, vorigin int64, count unsafe.Pointer) (*Span, error) { + _r0, _err := functions.BigintspanBins(functions.SpanFromPointer(x.Pointer()), vsize, vorigin, count) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} diff --git a/types/bigintspanset.go b/types/bigintspanset.go new file mode 100644 index 0000000..6422151 --- /dev/null +++ b/types/bigintspanset.go @@ -0,0 +1,87 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type BigIntSpanSet struct { + SpanSet +} + +// BigIntSpanSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func BigIntSpanSetFromPointer(p unsafe.Pointer) *BigIntSpanSet { + if p == nil { + return nil + } + v := &BigIntSpanSet{} + v.ptr = p + return v +} + +// BigIntSpanSetIn is MEOS bigintspanset_in. +func BigIntSpanSetIn(str string) (*SpanSet, error) { + _r0, _err := functions.BigintspansetIn(str) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS bigintspanset_out. +func (x *BigIntSpanSet) Out() (string, error) { + _r0, _err := functions.BigintspansetOut(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// Lower is MEOS bigintspanset_lower. +func (x *BigIntSpanSet) Lower() (int64, error) { + _r0, _err := functions.BigintspansetLower(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Upper is MEOS bigintspanset_upper. +func (x *BigIntSpanSet) Upper() (int64, error) { + _r0, _err := functions.BigintspansetUpper(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Width is MEOS bigintspanset_width. +func (x *BigIntSpanSet) Width(boundspan bool) (int64, error) { + _r0, _err := functions.BigintspansetWidth(functions.SpanSetFromPointer(x.Pointer()), boundspan) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ShiftScale is MEOS bigintspanset_shift_scale. +func (x *BigIntSpanSet) ShiftScale(shift int64, width int64, hasshift bool, haswidth bool) (*SpanSet, error) { + _r0, _err := functions.BigintspansetShiftScale(functions.SpanSetFromPointer(x.Pointer()), shift, width, hasshift, haswidth) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// Bins is MEOS bigintspanset_bins. +func (x *BigIntSpanSet) Bins(vsize int64, vorigin int64, count unsafe.Pointer) (*Span, error) { + _r0, _err := functions.BigintspansetBins(functions.SpanSetFromPointer(x.Pointer()), vsize, vorigin, count) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} diff --git a/types/box.go b/types/box.go new file mode 100644 index 0000000..e97f973 --- /dev/null +++ b/types/box.go @@ -0,0 +1,22 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" +) + +type Box struct { + handle +} + +// BoxFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func BoxFromPointer(p unsafe.Pointer) *Box { + if p == nil { + return nil + } + v := &Box{} + v.ptr = p + return v +} diff --git a/types/cbuffer.go b/types/cbuffer.go new file mode 100644 index 0000000..44ededc --- /dev/null +++ b/types/cbuffer.go @@ -0,0 +1,321 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type Cbuffer struct { + Value +} + +// CbufferFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func CbufferFromPointer(p unsafe.Pointer) *Cbuffer { + if p == nil { + return nil + } + v := &Cbuffer{} + v.ptr = p + return v +} + +// AsEWKT is MEOS cbuffer_as_ewkt. +func (x *Cbuffer) AsEWKT(maxdd int) (string, error) { + _r0, _err := functions.CbufferAsEWKT(functions.CbufferFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// 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) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// AsText is MEOS cbuffer_as_text. +func (x *Cbuffer) AsText(maxdd int) (string, error) { + _r0, _err := functions.CbufferAsText(functions.CbufferFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// 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) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// CbufferFromHEXWKB is MEOS cbuffer_from_hexwkb. +func CbufferFromHEXWKB(hexwkb string) (*Cbuffer, error) { + _r0, _err := functions.CbufferFromHexwkb(hexwkb) + if _err != nil { + return nil, _err + } + return CbufferFromPointer(_r0.Pointer()), nil +} + +// CbufferFromWKB is MEOS cbuffer_from_wkb. +func CbufferFromWKB(wkb unsafe.Pointer, size uint) (*Cbuffer, error) { + _r0, _err := functions.CbufferFromWKB(wkb, size) + if _err != nil { + return nil, _err + } + return CbufferFromPointer(_r0.Pointer()), nil +} + +// CbufferIn is MEOS cbuffer_in. +func CbufferIn(str string) (*Cbuffer, error) { + _r0, _err := functions.CbufferIn(str) + if _err != nil { + return nil, _err + } + return CbufferFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS cbuffer_out. +func (x *Cbuffer) Out(maxdd int) (string, error) { + _r0, _err := functions.CbufferOut(functions.CbufferFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// Copy is MEOS cbuffer_copy. +func (x *Cbuffer) Copy() (*Cbuffer, error) { + _r0, _err := functions.CbufferCopy(functions.CbufferFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return CbufferFromPointer(_r0.Pointer()), nil +} + +// CbufferMake is MEOS cbuffer_make. +func CbufferMake(point *TRGeometrySeqSet, radius float64) (*Cbuffer, error) { + _r0, _err := functions.CbufferMake(functions.GeomFromPointer(point.Pointer()), radius) + if _err != nil { + return nil, _err + } + return CbufferFromPointer(_r0.Pointer()), nil +} + +// ToGeom is MEOS cbuffer_to_geom. +func (x *Cbuffer) ToGeom() (*TRGeometrySeqSet, error) { + _r0, _err := functions.CbufferToGeom(functions.CbufferFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// ToStbox is MEOS cbuffer_to_stbox. +func (x *Cbuffer) ToStbox() (*STBox, error) { + _r0, _err := functions.CbufferToSTBOX(functions.CbufferFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// Hash is MEOS cbuffer_hash. +func (x *Cbuffer) Hash() (uint32, error) { + _r0, _err := functions.CbufferHash(functions.CbufferFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// HashExtended is MEOS cbuffer_hash_extended. +func (x *Cbuffer) HashExtended(seed uint64) (uint64, error) { + _r0, _err := functions.CbufferHashExtended(functions.CbufferFromPointer(x.Pointer()), seed) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Point is MEOS cbuffer_point. +func (x *Cbuffer) Point() (*TRGeometrySeqSet, error) { + _r0, _err := functions.CbufferPoint(functions.CbufferFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// Radius is MEOS cbuffer_radius. +func (x *Cbuffer) Radius() (float64, error) { + _r0, _err := functions.CbufferRadius(functions.CbufferFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Round is MEOS cbuffer_round. +func (x *Cbuffer) Round(maxdd int) (*Cbuffer, error) { + _r0, _err := functions.CbufferRound(functions.CbufferFromPointer(x.Pointer()), maxdd) + if _err != nil { + return nil, _err + } + return CbufferFromPointer(_r0.Pointer()), nil +} + +// SetSRID is MEOS cbuffer_set_srid. +func (x *Cbuffer) SetSRID(srid int32) (*Cbuffer, error) { + _r0, _err := functions.CbufferSetSRID(functions.CbufferFromPointer(x.Pointer()), srid) + if _err != nil { + return nil, _err + } + return CbufferFromPointer(_r0.Pointer()), nil +} + +// SRID is MEOS cbuffer_srid. +func (x *Cbuffer) SRID() (int32, error) { + _r0, _err := functions.CbufferSRID(functions.CbufferFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Transform is MEOS cbuffer_transform. +func (x *Cbuffer) Transform(srid int32) (*Cbuffer, error) { + _r0, _err := functions.CbufferTransform(functions.CbufferFromPointer(x.Pointer()), srid) + if _err != nil { + return nil, _err + } + return CbufferFromPointer(_r0.Pointer()), nil +} + +// TransformPipeline is MEOS cbuffer_transform_pipeline. +func (x *Cbuffer) TransformPipeline(pipelinestr string, srid int32, is_forward bool) (*Cbuffer, error) { + _r0, _err := functions.CbufferTransformPipeline(functions.CbufferFromPointer(x.Pointer()), pipelinestr, srid, is_forward) + if _err != nil { + return nil, _err + } + return CbufferFromPointer(_r0.Pointer()), nil +} + +// TstzspanToStbox is MEOS cbuffer_tstzspan_to_stbox. +func (x *Cbuffer) TstzspanToStbox(s *Span) (*STBox, error) { + _r0, _err := functions.CbufferTstzspanToSTBOX(functions.CbufferFromPointer(x.Pointer()), functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// TimestamptzToStbox is MEOS cbuffer_timestamptz_to_stbox. +func (x *Cbuffer) TimestamptzToStbox(t int64) (*STBox, error) { + _r0, _err := functions.CbufferTimestamptzToSTBOX(functions.CbufferFromPointer(x.Pointer()), t) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// Cmp is MEOS cbuffer_cmp. +func (x *Cbuffer) Cmp(cb2 *Cbuffer) (int, error) { + _r0, _err := functions.CbufferCmp(functions.CbufferFromPointer(x.Pointer()), functions.CbufferFromPointer(cb2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Eq is MEOS cbuffer_eq. +func (x *Cbuffer) Eq(cb2 *Cbuffer) (bool, error) { + _r0, _err := functions.CbufferEq(functions.CbufferFromPointer(x.Pointer()), functions.CbufferFromPointer(cb2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Ge is MEOS cbuffer_ge. +func (x *Cbuffer) Ge(cb2 *Cbuffer) (bool, error) { + _r0, _err := functions.CbufferGe(functions.CbufferFromPointer(x.Pointer()), functions.CbufferFromPointer(cb2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Gt is MEOS cbuffer_gt. +func (x *Cbuffer) Gt(cb2 *Cbuffer) (bool, error) { + _r0, _err := functions.CbufferGt(functions.CbufferFromPointer(x.Pointer()), functions.CbufferFromPointer(cb2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Le is MEOS cbuffer_le. +func (x *Cbuffer) Le(cb2 *Cbuffer) (bool, error) { + _r0, _err := functions.CbufferLe(functions.CbufferFromPointer(x.Pointer()), functions.CbufferFromPointer(cb2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Lt is MEOS cbuffer_lt. +func (x *Cbuffer) Lt(cb2 *Cbuffer) (bool, error) { + _r0, _err := functions.CbufferLt(functions.CbufferFromPointer(x.Pointer()), functions.CbufferFromPointer(cb2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Ne is MEOS cbuffer_ne. +func (x *Cbuffer) Ne(cb2 *Cbuffer) (bool, error) { + _r0, _err := functions.CbufferNe(functions.CbufferFromPointer(x.Pointer()), functions.CbufferFromPointer(cb2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Nsame is MEOS cbuffer_nsame. +func (x *Cbuffer) Nsame(cb2 *Cbuffer) (bool, error) { + _r0, _err := functions.CbufferNsame(functions.CbufferFromPointer(x.Pointer()), functions.CbufferFromPointer(cb2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Same is MEOS cbuffer_same. +func (x *Cbuffer) Same(cb2 *Cbuffer) (bool, error) { + _r0, _err := functions.CbufferSame(functions.CbufferFromPointer(x.Pointer()), functions.CbufferFromPointer(cb2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// ToSet is MEOS cbuffer_to_set. +func (x *Cbuffer) ToSet() (*Set, error) { + _r0, _err := functions.CbufferToSet(functions.CbufferFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} diff --git a/types/cbufferset.go b/types/cbufferset.go new file mode 100644 index 0000000..433ac07 --- /dev/null +++ b/types/cbufferset.go @@ -0,0 +1,90 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type CbufferSet struct { + Set +} + +// CbufferSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func CbufferSetFromPointer(p unsafe.Pointer) *CbufferSet { + if p == nil { + return nil + } + v := &CbufferSet{} + v.ptr = p + return v +} + +// CbufferSetIn is MEOS cbufferset_in. +func CbufferSetIn(str string) (*Set, error) { + _r0, _err := functions.CbuffersetIn(str) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS cbufferset_out. +func (x *CbufferSet) Out(maxdd int) (string, error) { + _r0, _err := functions.CbuffersetOut(functions.SetFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// CbufferSetMake is MEOS cbufferset_make. +func CbufferSetMake(values unsafe.Pointer, count int) (*Set, error) { + _r0, _err := functions.CbuffersetMake(values, count) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS cbufferset_end_value. +func (x *CbufferSet) EndValue() (*Cbuffer, error) { + _r0, _err := functions.CbuffersetEndValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return CbufferFromPointer(_r0.Pointer()), nil +} + +// StartValue is MEOS cbufferset_start_value. +func (x *CbufferSet) StartValue() (*Cbuffer, error) { + _r0, _err := functions.CbuffersetStartValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return CbufferFromPointer(_r0.Pointer()), nil +} + +// ValueN is MEOS cbufferset_value_n. +func (x *CbufferSet) ValueN(n int) (*Cbuffer, bool, error) { + _found, _value, _err := functions.CbuffersetValueN(functions.SetFromPointer(x.Pointer()), n) + if _err != nil { + return nil, false, _err + } + if !_found { + return nil, false, nil + } + return CbufferFromPointer(_value.Pointer()), true, nil +} + +// Values is MEOS cbufferset_values. +func (x *CbufferSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.CbuffersetValues(functions.SetFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} diff --git a/types/collection.go b/types/collection.go new file mode 100644 index 0000000..8a727b8 --- /dev/null +++ b/types/collection.go @@ -0,0 +1,22 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" +) + +type Collection struct { + handle +} + +// CollectionFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func CollectionFromPointer(p unsafe.Pointer) *Collection { + if p == nil { + return nil + } + v := &Collection{} + v.ptr = p + return v +} diff --git a/types/dateset.go b/types/dateset.go new file mode 100644 index 0000000..5234bb5 --- /dev/null +++ b/types/dateset.go @@ -0,0 +1,108 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type DateSet struct { + Set +} + +// DateSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func DateSetFromPointer(p unsafe.Pointer) *DateSet { + if p == nil { + return nil + } + v := &DateSet{} + v.ptr = p + return v +} + +// DateSetIn is MEOS dateset_in. +func DateSetIn(str string) (*Set, error) { + _r0, _err := functions.DatesetIn(str) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS dateset_out. +func (x *DateSet) Out() (string, error) { + _r0, _err := functions.DatesetOut(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// DateSetMake is MEOS dateset_make. +func DateSetMake(values unsafe.Pointer, count int) (*Set, error) { + _r0, _err := functions.DatesetMake(values, count) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// ToTstzset is MEOS dateset_to_tstzset. +func (x *DateSet) ToTstzset() (*Set, error) { + _r0, _err := functions.DatesetToTstzset(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS dateset_end_value. +func (x *DateSet) EndValue() (int32, error) { + _r0, _err := functions.DatesetEndValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// StartValue is MEOS dateset_start_value. +func (x *DateSet) StartValue() (int32, error) { + _r0, _err := functions.DatesetStartValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ValueN is MEOS dateset_value_n. +func (x *DateSet) ValueN(n int) (int32, bool, error) { + _found, _value, _err := functions.DatesetValueN(functions.SetFromPointer(x.Pointer()), n) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// Values is MEOS dateset_values. +func (x *DateSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.DatesetValues(functions.SetFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// ShiftScale is MEOS dateset_shift_scale. +func (x *DateSet) ShiftScale(shift int, width int, hasshift bool, haswidth bool) (*Set, error) { + _r0, _err := functions.DatesetShiftScale(functions.SetFromPointer(x.Pointer()), shift, width, hasshift, haswidth) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} diff --git a/types/datespan.go b/types/datespan.go new file mode 100644 index 0000000..44d9b70 --- /dev/null +++ b/types/datespan.go @@ -0,0 +1,87 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type DateSpan struct { + Span +} + +// DateSpanFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func DateSpanFromPointer(p unsafe.Pointer) *DateSpan { + if p == nil { + return nil + } + v := &DateSpan{} + v.ptr = p + return v +} + +// DateSpanIn is MEOS datespan_in. +func DateSpanIn(str string) (*Span, error) { + _r0, _err := functions.DatespanIn(str) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS datespan_out. +func (x *DateSpan) Out() (string, error) { + _r0, _err := functions.DatespanOut(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// DateSpanMake is MEOS datespan_make. +func DateSpanMake(lower int32, upper int32, lower_inc bool, upper_inc bool) (*Span, error) { + _r0, _err := functions.DatespanMake(lower, upper, lower_inc, upper_inc) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// ToTstzspan is MEOS datespan_to_tstzspan. +func (x *DateSpan) ToTstzspan() (*Span, error) { + _r0, _err := functions.DatespanToTstzspan(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Lower is MEOS datespan_lower. +func (x *DateSpan) Lower() (int32, error) { + _r0, _err := functions.DatespanLower(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Upper is MEOS datespan_upper. +func (x *DateSpan) Upper() (int32, error) { + _r0, _err := functions.DatespanUpper(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ShiftScale is MEOS datespan_shift_scale. +func (x *DateSpan) ShiftScale(shift int, width int, hasshift bool, haswidth bool) (*Span, error) { + _r0, _err := functions.DatespanShiftScale(functions.SpanFromPointer(x.Pointer()), shift, width, hasshift, haswidth) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} diff --git a/types/datespanset.go b/types/datespanset.go new file mode 100644 index 0000000..ec592d3 --- /dev/null +++ b/types/datespanset.go @@ -0,0 +1,126 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type DateSpanSet struct { + SpanSet +} + +// DateSpanSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func DateSpanSetFromPointer(p unsafe.Pointer) *DateSpanSet { + if p == nil { + return nil + } + v := &DateSpanSet{} + v.ptr = p + return v +} + +// DateSpanSetIn is MEOS datespanset_in. +func DateSpanSetIn(str string) (*SpanSet, error) { + _r0, _err := functions.DatespansetIn(str) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS datespanset_out. +func (x *DateSpanSet) Out() (string, error) { + _r0, _err := functions.DatespansetOut(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// ToTstzspanset is MEOS datespanset_to_tstzspanset. +func (x *DateSpanSet) ToTstzspanset() (*SpanSet, error) { + _r0, _err := functions.DatespansetToTstzspanset(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// DateN is MEOS datespanset_date_n. +func (x *DateSpanSet) DateN(n int) (int32, bool, error) { + _found, _value, _err := functions.DatespansetDateN(functions.SpanSetFromPointer(x.Pointer()), n) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// Dates is MEOS datespanset_dates. +func (x *DateSpanSet) Dates() (*Set, error) { + _r0, _err := functions.DatespansetDates(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// EndDate is MEOS datespanset_end_date. +func (x *DateSpanSet) EndDate() (int32, error) { + _r0, _err := functions.DatespansetEndDate(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Lower is MEOS datespanset_lower. +func (x *DateSpanSet) Lower() (int32, error) { + _r0, _err := functions.DatespansetLower(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// NumDates is MEOS datespanset_num_dates. +func (x *DateSpanSet) NumDates() (int, error) { + _r0, _err := functions.DatespansetNumDates(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// StartDate is MEOS datespanset_start_date. +func (x *DateSpanSet) StartDate() (int32, error) { + _r0, _err := functions.DatespansetStartDate(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Upper is MEOS datespanset_upper. +func (x *DateSpanSet) Upper() (int32, error) { + _r0, _err := functions.DatespansetUpper(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ShiftScale is MEOS datespanset_shift_scale. +func (x *DateSpanSet) ShiftScale(shift int, width int, hasshift bool, haswidth bool) (*SpanSet, error) { + _r0, _err := functions.DatespansetShiftScale(functions.SpanSetFromPointer(x.Pointer()), shift, width, hasshift, haswidth) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} diff --git a/types/floatset.go b/types/floatset.go new file mode 100644 index 0000000..ba8305e --- /dev/null +++ b/types/floatset.go @@ -0,0 +1,144 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type FloatSet struct { + Set +} + +// FloatSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func FloatSetFromPointer(p unsafe.Pointer) *FloatSet { + if p == nil { + return nil + } + v := &FloatSet{} + v.ptr = p + return v +} + +// FloatSetIn is MEOS floatset_in. +func FloatSetIn(str string) (*Set, error) { + _r0, _err := functions.FloatsetIn(str) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS floatset_out. +func (x *FloatSet) Out(maxdd int) (string, error) { + _r0, _err := functions.FloatsetOut(functions.SetFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// FloatSetMake is MEOS floatset_make. +func FloatSetMake(values unsafe.Pointer, count int) (*Set, error) { + _r0, _err := functions.FloatsetMake(values, count) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// ToIntset is MEOS floatset_to_intset. +func (x *FloatSet) ToIntset() (*Set, error) { + _r0, _err := functions.FloatsetToIntset(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS floatset_end_value. +func (x *FloatSet) EndValue() (float64, error) { + _r0, _err := functions.FloatsetEndValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// StartValue is MEOS floatset_start_value. +func (x *FloatSet) StartValue() (float64, error) { + _r0, _err := functions.FloatsetStartValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ValueN is MEOS floatset_value_n. +func (x *FloatSet) ValueN(n int) (float64, bool, error) { + _found, _value, _err := functions.FloatsetValueN(functions.SetFromPointer(x.Pointer()), n) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// Values is MEOS floatset_values. +func (x *FloatSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.FloatsetValues(functions.SetFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Ceil is MEOS floatset_ceil. +func (x *FloatSet) Ceil() (*Set, error) { + _r0, _err := functions.FloatsetCeil(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Degrees is MEOS floatset_degrees. +func (x *FloatSet) Degrees(normalize bool) (*Set, error) { + _r0, _err := functions.FloatsetDegrees(functions.SetFromPointer(x.Pointer()), normalize) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Floor is MEOS floatset_floor. +func (x *FloatSet) Floor() (*Set, error) { + _r0, _err := functions.FloatsetFloor(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Radians is MEOS floatset_radians. +func (x *FloatSet) Radians() (*Set, error) { + _r0, _err := functions.FloatsetRadians(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// ShiftScale is MEOS floatset_shift_scale. +func (x *FloatSet) ShiftScale(shift float64, width float64, hasshift bool, haswidth bool) (*Set, error) { + _r0, _err := functions.FloatsetShiftScale(functions.SetFromPointer(x.Pointer()), shift, width, hasshift, haswidth) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} diff --git a/types/floatspan.go b/types/floatspan.go new file mode 100644 index 0000000..748f6b4 --- /dev/null +++ b/types/floatspan.go @@ -0,0 +1,168 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type FloatSpan struct { + Span +} + +// FloatSpanFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func FloatSpanFromPointer(p unsafe.Pointer) *FloatSpan { + if p == nil { + return nil + } + v := &FloatSpan{} + v.ptr = p + return v +} + +// Expand is MEOS floatspan_expand. +func (x *FloatSpan) Expand(value float64) (*Span, error) { + _r0, _err := functions.FloatspanExpand(functions.SpanFromPointer(x.Pointer()), value) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// FloatSpanIn is MEOS floatspan_in. +func FloatSpanIn(str string) (*Span, error) { + _r0, _err := functions.FloatspanIn(str) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS floatspan_out. +func (x *FloatSpan) Out(maxdd int) (string, error) { + _r0, _err := functions.FloatspanOut(functions.SpanFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// FloatSpanMake is MEOS floatspan_make. +func FloatSpanMake(lower float64, upper float64, lower_inc bool, upper_inc bool) (*Span, error) { + _r0, _err := functions.FloatspanMake(lower, upper, lower_inc, upper_inc) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// ToIntspan is MEOS floatspan_to_intspan. +func (x *FloatSpan) ToIntspan() (*Span, error) { + _r0, _err := functions.FloatspanToIntspan(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// ToBigintspan is MEOS floatspan_to_bigintspan. +func (x *FloatSpan) ToBigintspan() (*Span, error) { + _r0, _err := functions.FloatspanToBigintspan(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Lower is MEOS floatspan_lower. +func (x *FloatSpan) Lower() (float64, error) { + _r0, _err := functions.FloatspanLower(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Upper is MEOS floatspan_upper. +func (x *FloatSpan) Upper() (float64, error) { + _r0, _err := functions.FloatspanUpper(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Width is MEOS floatspan_width. +func (x *FloatSpan) Width() (float64, error) { + _r0, _err := functions.FloatspanWidth(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Ceil is MEOS floatspan_ceil. +func (x *FloatSpan) Ceil() (*Span, error) { + _r0, _err := functions.FloatspanCeil(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Degrees is MEOS floatspan_degrees. +func (x *FloatSpan) Degrees(normalize bool) (*Span, error) { + _r0, _err := functions.FloatspanDegrees(functions.SpanFromPointer(x.Pointer()), normalize) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Floor is MEOS floatspan_floor. +func (x *FloatSpan) Floor() (*Span, error) { + _r0, _err := functions.FloatspanFloor(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Radians is MEOS floatspan_radians. +func (x *FloatSpan) Radians() (*Span, error) { + _r0, _err := functions.FloatspanRadians(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Round is MEOS floatspan_round. +func (x *FloatSpan) Round(maxdd int) (*Span, error) { + _r0, _err := functions.FloatspanRound(functions.SpanFromPointer(x.Pointer()), maxdd) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// ShiftScale is MEOS floatspan_shift_scale. +func (x *FloatSpan) ShiftScale(shift float64, width float64, hasshift bool, haswidth bool) (*Span, error) { + _r0, _err := functions.FloatspanShiftScale(functions.SpanFromPointer(x.Pointer()), shift, width, hasshift, haswidth) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Bins is MEOS floatspan_bins. +func (x *FloatSpan) Bins(vsize float64, vorigin float64, count unsafe.Pointer) (*Span, error) { + _r0, _err := functions.FloatspanBins(functions.SpanFromPointer(x.Pointer()), vsize, vorigin, count) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} diff --git a/types/floatspanset.go b/types/floatspanset.go new file mode 100644 index 0000000..a8aa492 --- /dev/null +++ b/types/floatspanset.go @@ -0,0 +1,141 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type FloatSpanSet struct { + SpanSet +} + +// FloatSpanSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func FloatSpanSetFromPointer(p unsafe.Pointer) *FloatSpanSet { + if p == nil { + return nil + } + v := &FloatSpanSet{} + v.ptr = p + return v +} + +// FloatSpanSetIn is MEOS floatspanset_in. +func FloatSpanSetIn(str string) (*SpanSet, error) { + _r0, _err := functions.FloatspansetIn(str) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS floatspanset_out. +func (x *FloatSpanSet) Out(maxdd int) (string, error) { + _r0, _err := functions.FloatspansetOut(functions.SpanSetFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// ToIntspanset is MEOS floatspanset_to_intspanset. +func (x *FloatSpanSet) ToIntspanset() (*SpanSet, error) { + _r0, _err := functions.FloatspansetToIntspanset(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// Lower is MEOS floatspanset_lower. +func (x *FloatSpanSet) Lower() (float64, error) { + _r0, _err := functions.FloatspansetLower(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Upper is MEOS floatspanset_upper. +func (x *FloatSpanSet) Upper() (float64, error) { + _r0, _err := functions.FloatspansetUpper(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Width is MEOS floatspanset_width. +func (x *FloatSpanSet) Width(boundspan bool) (float64, error) { + _r0, _err := functions.FloatspansetWidth(functions.SpanSetFromPointer(x.Pointer()), boundspan) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Ceil is MEOS floatspanset_ceil. +func (x *FloatSpanSet) Ceil() (*SpanSet, error) { + _r0, _err := functions.FloatspansetCeil(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// Floor is MEOS floatspanset_floor. +func (x *FloatSpanSet) Floor() (*SpanSet, error) { + _r0, _err := functions.FloatspansetFloor(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// Degrees is MEOS floatspanset_degrees. +func (x *FloatSpanSet) Degrees(normalize bool) (*SpanSet, error) { + _r0, _err := functions.FloatspansetDegrees(functions.SpanSetFromPointer(x.Pointer()), normalize) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// Radians is MEOS floatspanset_radians. +func (x *FloatSpanSet) Radians() (*SpanSet, error) { + _r0, _err := functions.FloatspansetRadians(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// Round is MEOS floatspanset_round. +func (x *FloatSpanSet) Round(maxdd int) (*SpanSet, error) { + _r0, _err := functions.FloatspansetRound(functions.SpanSetFromPointer(x.Pointer()), maxdd) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// ShiftScale is MEOS floatspanset_shift_scale. +func (x *FloatSpanSet) ShiftScale(shift float64, width float64, hasshift bool, haswidth bool) (*SpanSet, error) { + _r0, _err := functions.FloatspansetShiftScale(functions.SpanSetFromPointer(x.Pointer()), shift, width, hasshift, haswidth) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// Bins is MEOS floatspanset_bins. +func (x *FloatSpanSet) Bins(vsize float64, vorigin float64, count unsafe.Pointer) (*Span, error) { + _r0, _err := functions.FloatspansetBins(functions.SpanSetFromPointer(x.Pointer()), vsize, vorigin, count) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} diff --git a/types/geo.go b/types/geo.go new file mode 100644 index 0000000..51c20a0 --- /dev/null +++ b/types/geo.go @@ -0,0 +1,402 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type Geo struct { + Value +} + +// GeoFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func GeoFromPointer(p unsafe.Pointer) *Geo { + if p == nil { + return nil + } + v := &Geo{} + v.ptr = p + return v +} + +// 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) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// GeoAsEWKT is MEOS geo_as_ewkt. +func GeoAsEWKT(gs *TRGeometrySeqSet, precision int) (string, error) { + _r0, _err := functions.GeoAsEWKT(functions.GeomFromPointer(gs.Pointer()), precision) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// GeoAsGEOJSON is MEOS geo_as_geojson. +func GeoAsGEOJSON(gs *TRGeometrySeqSet, option int, precision int, srs string) (string, error) { + _r0, _err := functions.GeoAsGeojson(functions.GeomFromPointer(gs.Pointer()), option, precision, srs) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// GeoAsHEXEWKB is MEOS geo_as_hexewkb. +func GeoAsHEXEWKB(gs *TRGeometrySeqSet, endian string) (string, error) { + _r0, _err := functions.GeoAsHexewkb(functions.GeomFromPointer(gs.Pointer()), endian) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// GeoAsText is MEOS geo_as_text. +func GeoAsText(gs *TRGeometrySeqSet, precision int) (string, error) { + _r0, _err := functions.GeoAsText(functions.GeomFromPointer(gs.Pointer()), precision) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// 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) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeoFromGEOJSON is MEOS geo_from_geojson. +func GeoFromGEOJSON(geojson string) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeoFromGeojson(geojson) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeoFromText is MEOS geo_from_text. +func GeoFromText(wkt string, srid int32) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeoFromText(wkt, srid) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeoOut is MEOS geo_out. +func GeoOut(gs *TRGeometrySeqSet) (string, error) { + _r0, _err := functions.GeoOut(functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// GeoCopy is MEOS geo_copy. +func GeoCopy(gs *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeoCopy(functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeoIsEmpty is MEOS geo_is_empty. +func GeoIsEmpty(gs *TRGeometrySeqSet) (bool, error) { + _r0, _err := functions.GeoIsEmpty(functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// GeoIsUnitary is MEOS geo_is_unitary. +func GeoIsUnitary(gs *TRGeometrySeqSet) (bool, error) { + _r0, _err := functions.GeoIsUnitary(functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// GeoTypename is MEOS geo_typename. +func GeoTypename(type_ int) (string, error) { + _r0, _err := functions.GeoTypename(type_) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// GeoReverse is MEOS geo_reverse. +func GeoReverse(gs *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeoReverse(functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeoRound is MEOS geo_round. +func GeoRound(gs *TRGeometrySeqSet, maxdd int) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeoRound(functions.GeomFromPointer(gs.Pointer()), maxdd) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeoSetSRID is MEOS geo_set_srid. +func GeoSetSRID(gs *TRGeometrySeqSet, srid int32) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeoSetSRID(functions.GeomFromPointer(gs.Pointer()), srid) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeoSRID is MEOS geo_srid. +func GeoSRID(gs *TRGeometrySeqSet) (int32, error) { + _r0, _err := functions.GeoSRID(functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// GeoTransform is MEOS geo_transform. +func GeoTransform(geom *TRGeometrySeqSet, srid_to int32) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeoTransform(functions.GeomFromPointer(geom.Pointer()), srid_to) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeoTransformPipeline is MEOS geo_transform_pipeline. +func GeoTransformPipeline(gs *TRGeometrySeqSet, pipeline string, srid_to int32, is_forward bool) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeoTransformPipeline(functions.GeomFromPointer(gs.Pointer()), pipeline, srid_to, is_forward) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeoCollectGarray is MEOS geo_collect_garray. +func GeoCollectGarray(gsarr unsafe.Pointer, count int) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeoCollectGarray(gsarr, count) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeoMakelineGarray is MEOS geo_makeline_garray. +func GeoMakelineGarray(gsarr unsafe.Pointer, count int) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeoMakelineGarray(gsarr, count) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeoNumPoints is MEOS geo_num_points. +func GeoNumPoints(gs *TRGeometrySeqSet) (int, error) { + _r0, _err := functions.GeoNumPoints(functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// GeoNumGeos is MEOS geo_num_geos. +func GeoNumGeos(gs *TRGeometrySeqSet) (int, error) { + _r0, _err := functions.GeoNumGeos(functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// GeoGeoN is MEOS geo_geo_n. +func GeoGeoN(geom *TRGeometrySeqSet, n int) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeoGeoN(functions.GeomFromPointer(geom.Pointer()), n) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeoPointarr is MEOS geo_pointarr. +func GeoPointarr(gs *TRGeometrySeqSet, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.GeoPointarr(functions.GeomFromPointer(gs.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// GeoPoints is MEOS geo_points. +func GeoPoints(gs *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeoPoints(functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeoStboxes is MEOS geo_stboxes. +func GeoStboxes(gs *TRGeometrySeqSet, count unsafe.Pointer) (*STBox, error) { + _r0, _err := functions.GeoStboxes(functions.GeomFromPointer(gs.Pointer()), count) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// GeoSplitEachNStboxes is MEOS geo_split_each_n_stboxes. +func GeoSplitEachNStboxes(gs *TRGeometrySeqSet, elem_count int, count unsafe.Pointer) (*STBox, error) { + _r0, _err := functions.GeoSplitEachNStboxes(functions.GeomFromPointer(gs.Pointer()), elem_count, count) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// GeoSplitNStboxes is MEOS geo_split_n_stboxes. +func GeoSplitNStboxes(gs *TRGeometrySeqSet, box_count int, count unsafe.Pointer) (*STBox, error) { + _r0, _err := functions.GeoSplitNStboxes(functions.GeomFromPointer(gs.Pointer()), box_count, count) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// GeoEquals is MEOS geo_equals. +func GeoEquals(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (int, error) { + _r0, _err := functions.GeoEquals(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// GeoSame is MEOS geo_same. +func GeoSame(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (bool, error) { + _r0, _err := functions.GeoSame(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// GeoToSet is MEOS geo_to_set. +func GeoToSet(gs *TRGeometrySeqSet) (*Set, error) { + _r0, _err := functions.GeoToSet(functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// GeoTimestamptzToStbox is MEOS geo_timestamptz_to_stbox. +func GeoTimestamptzToStbox(gs *TRGeometrySeqSet, t int64) (*STBox, error) { + _r0, _err := functions.GeoTimestamptzToSTBOX(functions.GeomFromPointer(gs.Pointer()), t) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// GeoTstzspanToStbox is MEOS geo_tstzspan_to_stbox. +func GeoTstzspanToStbox(gs *TRGeometrySeqSet, s *Span) (*STBox, error) { + _r0, _err := functions.GeoTstzspanToSTBOX(functions.GeomFromPointer(gs.Pointer()), functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// GeoToStbox is MEOS geo_to_stbox. +func GeoToStbox(gs *TRGeometrySeqSet) (*STBox, error) { + _r0, _err := functions.GeoToSTBOX(functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// GeoClusterKmeans is MEOS geo_cluster_kmeans. +func GeoClusterKmeans(geoms unsafe.Pointer, ngeoms uint32, k uint32, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.GeoClusterKmeans(geoms, ngeoms, k, count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// GeoClusterDbscan is MEOS geo_cluster_dbscan. +func GeoClusterDbscan(geoms unsafe.Pointer, ngeoms uint32, tolerance float64, minpoints int, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.GeoClusterDbscan(geoms, ngeoms, tolerance, minpoints, count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// GeoClusterIntersecting is MEOS geo_cluster_intersecting. +func GeoClusterIntersecting(geoms unsafe.Pointer, ngeoms uint32, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.GeoClusterIntersecting(geoms, ngeoms, count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// GeoClusterWithin is MEOS geo_cluster_within. +func GeoClusterWithin(geoms unsafe.Pointer, ngeoms uint32, tolerance float64, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.GeoClusterWithin(geoms, ngeoms, tolerance, count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// GeoToH3indexCell is MEOS geo_to_h3index_cell. +func GeoToH3indexCell(point *TRGeometrySeqSet, resolution int32) (uint64, error) { + _r0, _err := functions.GeoToH3indexCell(functions.GeomFromPointer(point.Pointer()), resolution) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// GeoToH3indexSet is MEOS geo_to_h3index_set. +func GeoToH3indexSet(gs *TRGeometrySeqSet, resolution int32) (*Set, error) { + _r0, _err := functions.GeoToH3indexSet(functions.GeomFromPointer(gs.Pointer()), resolution) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// GeoToQuadbinCell is MEOS geo_to_quadbin_cell. +func GeoToQuadbinCell(point *TRGeometrySeqSet, resolution int32) (uint64, error) { + _r0, _err := functions.GeoToQuadbinCell(functions.GeomFromPointer(point.Pointer()), resolution) + if _err != nil { + return 0, _err + } + return _r0, nil +} diff --git a/types/geography.go b/types/geography.go new file mode 100644 index 0000000..cb18390 --- /dev/null +++ b/types/geography.go @@ -0,0 +1,114 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type Geography struct { + Geo +} + +// GeographyFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func GeographyFromPointer(p unsafe.Pointer) *Geography { + if p == nil { + return nil + } + v := &Geography{} + v.ptr = p + return v +} + +// GeographyFromHEXEWKB is MEOS geog_from_hexewkb. +func GeographyFromHEXEWKB(wkt string) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeogFromHexewkb(wkt) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeographyIn is MEOS geog_in. +func GeographyIn(str string, typmod int32) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeogIn(str, typmod) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeographyToGeom is MEOS geog_to_geom. +func GeographyToGeom(geog *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeogToGeom(functions.GeomFromPointer(geog.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeographyArea is MEOS geog_area. +func GeographyArea(gs *TRGeometrySeqSet, use_spheroid bool) (float64, error) { + _r0, _err := functions.GeogArea(functions.GeomFromPointer(gs.Pointer()), use_spheroid) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// GeographyCentroid is MEOS geog_centroid. +func GeographyCentroid(gs *TRGeometrySeqSet, use_spheroid bool) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeogCentroid(functions.GeomFromPointer(gs.Pointer()), use_spheroid) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeographyLength is MEOS geog_length. +func GeographyLength(gs *TRGeometrySeqSet, use_spheroid bool) (float64, error) { + _r0, _err := functions.GeogLength(functions.GeomFromPointer(gs.Pointer()), use_spheroid) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// GeographyPerimeter is MEOS geog_perimeter. +func GeographyPerimeter(gs *TRGeometrySeqSet, use_spheroid bool) (float64, error) { + _r0, _err := functions.GeogPerimeter(functions.GeomFromPointer(gs.Pointer()), use_spheroid) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// GeographyArrayUnion is MEOS geog_array_union. +func GeographyArrayUnion(gsarr unsafe.Pointer, count int) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeogArrayUnion(gsarr, count) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeographyDwithin is MEOS geog_dwithin. +func GeographyDwithin(g1 *TRGeometrySeqSet, g2 *TRGeometrySeqSet, tolerance float64, use_spheroid bool) (bool, error) { + _r0, _err := functions.GeogDwithin(functions.GeomFromPointer(g1.Pointer()), functions.GeomFromPointer(g2.Pointer()), tolerance, use_spheroid) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// GeographyDistance is MEOS geog_distance. +func GeographyDistance(g1 *TRGeometrySeqSet, g2 *TRGeometrySeqSet) (float64, error) { + _r0, _err := functions.GeogDistance(functions.GeomFromPointer(g1.Pointer()), functions.GeomFromPointer(g2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} diff --git a/types/geogset.go b/types/geogset.go new file mode 100644 index 0000000..f56730e --- /dev/null +++ b/types/geogset.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type GeogSet struct { + Set +} + +// GeogSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func GeogSetFromPointer(p unsafe.Pointer) *GeogSet { + if p == nil { + return nil + } + v := &GeogSet{} + v.ptr = p + return v +} + +// GeogSetIn is MEOS geogset_in. +func GeogSetIn(str string) (*Set, error) { + _r0, _err := functions.GeogsetIn(str) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} diff --git a/types/geometry.go b/types/geometry.go new file mode 100644 index 0000000..1b20685 --- /dev/null +++ b/types/geometry.go @@ -0,0 +1,360 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type Geometry struct { + Geo +} + +// GeometryFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func GeometryFromPointer(p unsafe.Pointer) *Geometry { + if p == nil { + return nil + } + v := &Geometry{} + v.ptr = p + return v +} + +// GeometryFromHEXEWKB is MEOS geom_from_hexewkb. +func GeometryFromHEXEWKB(wkt string) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeomFromHexewkb(wkt) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeometryIn is MEOS geom_in. +func GeometryIn(str string, typmod int32) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeomIn(str, typmod) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeometryToGeog is MEOS geom_to_geog. +func GeometryToGeog(geom *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeomToGeog(functions.GeomFromPointer(geom.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeometryAzimuth is MEOS geom_azimuth. +func GeometryAzimuth(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (float64, bool, error) { + _found, _value, _err := functions.GeomAzimuth(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// GeometryArea is MEOS geom_area. +func GeometryArea(gs *TRGeometrySeqSet) (float64, error) { + _r0, _err := functions.GeomArea(functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// GeometryLength is MEOS geom_length. +func GeometryLength(gs *TRGeometrySeqSet) (float64, error) { + _r0, _err := functions.GeomLength(functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// GeometryPerimeter is MEOS geom_perimeter. +func GeometryPerimeter(gs *TRGeometrySeqSet) (float64, error) { + _r0, _err := functions.GeomPerimeter(functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// GeometryArrayUnion is MEOS geom_array_union. +func GeometryArrayUnion(gsarr unsafe.Pointer, count int) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeomArrayUnion(gsarr, count) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeometryBoundary is MEOS geom_boundary. +func GeometryBoundary(gs *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeomBoundary(functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeometryBuffer is MEOS geom_buffer. +func GeometryBuffer(gs *TRGeometrySeqSet, size float64, params string) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeomBuffer(functions.GeomFromPointer(gs.Pointer()), size, params) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeometryCentroid is MEOS geom_centroid. +func GeometryCentroid(gs *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeomCentroid(functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeometryConvexHull is MEOS geom_convex_hull. +func GeometryConvexHull(gs *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeomConvexHull(functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeometryDifference2d is MEOS geom_difference2d. +func GeometryDifference2d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeomDifference2d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeometryIsSimple is MEOS geom_is_simple. +func GeometryIsSimple(gs *TRGeometrySeqSet) (bool, error) { + _r0, _err := functions.GeomIsSimple(functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// GeometryIntersection2d is MEOS geom_intersection2d. +func GeometryIntersection2d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeomIntersection2d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeometryIntersection2dColl is MEOS geom_intersection2d_coll. +func GeometryIntersection2dColl(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeomIntersection2dColl(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeometryMinBoundingRadius is MEOS geom_min_bounding_radius. +func GeometryMinBoundingRadius(geom *TRGeometrySeqSet, radius unsafe.Pointer) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeomMinBoundingRadius(functions.GeomFromPointer(geom.Pointer()), radius) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeometryOrientedEnvelope is MEOS geom_oriented_envelope. +func GeometryOrientedEnvelope(gs *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeomOrientedEnvelope(functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeometryShortestline2d is MEOS geom_shortestline2d. +func GeometryShortestline2d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeomShortestline2d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeometryShortestline3d is MEOS geom_shortestline3d. +func GeometryShortestline3d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeomShortestline3d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeometryUnaryUnion is MEOS geom_unary_union. +func GeometryUnaryUnion(gs *TRGeometrySeqSet, prec float64) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeomUnaryUnion(functions.GeomFromPointer(gs.Pointer()), prec) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeometryCovers is MEOS geom_covers. +func GeometryCovers(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (bool, error) { + _r0, _err := functions.GeomCovers(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// GeometryDisjoint2d is MEOS geom_disjoint2d. +func GeometryDisjoint2d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (bool, error) { + _r0, _err := functions.GeomDisjoint2d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// GeometryDwithin is MEOS geom_dwithin. +func GeometryDwithin(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet, tolerance float64) (bool, error) { + _r0, _err := functions.GeomDwithin(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer()), tolerance) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// GeometryDwithin2d is MEOS geom_dwithin2d. +func GeometryDwithin2d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet, tolerance float64) (bool, error) { + _r0, _err := functions.GeomDwithin2d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer()), tolerance) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// GeometryDwithin3d is MEOS geom_dwithin3d. +func GeometryDwithin3d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet, tolerance float64) (bool, error) { + _r0, _err := functions.GeomDwithin3d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer()), tolerance) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// GeometryIntersects2d is MEOS geom_intersects2d. +func GeometryIntersects2d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (bool, error) { + _r0, _err := functions.GeomIntersects2d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// GeometryIntersects3d is MEOS geom_intersects3d. +func GeometryIntersects3d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (bool, error) { + _r0, _err := functions.GeomIntersects3d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// GeometryRelate is MEOS geom_relate. +func GeometryRelate(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (string, error) { + _r0, _err := functions.GeomRelate(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// GeometryRelatePattern is MEOS geom_relate_pattern. +func GeometryRelatePattern(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet, patt string) (bool, error) { + _r0, _err := functions.GeomRelatePattern(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer()), patt) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// GeometryTouches is MEOS geom_touches. +func GeometryTouches(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (bool, error) { + _r0, _err := functions.GeomTouches(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// GeometryDistance2d is MEOS geom_distance2d. +func GeometryDistance2d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (float64, error) { + _r0, _err := functions.GeomDistance2d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// GeometryMaxDistance2d is MEOS geom_max_distance2d. +func GeometryMaxDistance2d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (float64, error) { + _r0, _err := functions.GeomMaxDistance2d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// GeometryDistance3d is MEOS geom_distance3d. +func GeometryDistance3d(gs1 *TRGeometrySeqSet, gs2 *TRGeometrySeqSet) (float64, error) { + _r0, _err := functions.GeomDistance3d(functions.GeomFromPointer(gs1.Pointer()), functions.GeomFromPointer(gs2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// GeometryToCbuffer is MEOS geom_to_cbuffer. +func GeometryToCbuffer(gs *TRGeometrySeqSet) (*Cbuffer, error) { + _r0, _err := functions.GeomToCbuffer(functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return CbufferFromPointer(_r0.Pointer()), nil +} + +// GeometryToNsegment is MEOS geom_to_nsegment. +func GeometryToNsegment(gs *TRGeometrySeqSet) (*Nsegment, error) { + _r0, _err := functions.GeomToNsegment(functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return NsegmentFromPointer(_r0.Pointer()), nil +} + +// GeometryTposeToTrgeometry is MEOS geometry_tpose_to_trgeometry. +func GeometryTposeToTrgeometry(gs *TRGeometrySeqSet, temp *Temporal) (*Temporal, error) { + _r0, _err := functions.GeometryTposeToTrgeometry(functions.GeomFromPointer(gs.Pointer()), functions.TemporalFromPointer(temp.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/geomset.go b/types/geomset.go new file mode 100644 index 0000000..da0d951 --- /dev/null +++ b/types/geomset.go @@ -0,0 +1,81 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type GeomSet struct { + Set +} + +// GeomSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func GeomSetFromPointer(p unsafe.Pointer) *GeomSet { + if p == nil { + return nil + } + v := &GeomSet{} + v.ptr = p + return v +} + +// GeomSetIn is MEOS geomset_in. +func GeomSetIn(str string) (*Set, error) { + _r0, _err := functions.GeomsetIn(str) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// GeomSetMake is MEOS geoset_make. +func GeomSetMake(values unsafe.Pointer, count int) (*Set, error) { + _r0, _err := functions.GeosetMake(values, count) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS geoset_end_value. +func (x *GeomSet) EndValue() (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeosetEndValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// StartValue is MEOS geoset_start_value. +func (x *GeomSet) StartValue() (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeosetStartValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// ValueN is MEOS geoset_value_n. +func (x *GeomSet) ValueN(n int) (*TRGeometrySeqSet, bool, error) { + _found, _value, _err := functions.GeosetValueN(functions.SetFromPointer(x.Pointer()), n) + if _err != nil { + return nil, false, _err + } + if !_found { + return nil, false, nil + } + return TRGeometrySeqSetFromPointer(_value.Pointer()), true, nil +} + +// Values is MEOS geoset_values. +func (x *GeomSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.GeosetValues(functions.SetFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} diff --git a/types/intset.go b/types/intset.go new file mode 100644 index 0000000..394846a --- /dev/null +++ b/types/intset.go @@ -0,0 +1,108 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type IntSet struct { + Set +} + +// IntSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func IntSetFromPointer(p unsafe.Pointer) *IntSet { + if p == nil { + return nil + } + v := &IntSet{} + v.ptr = p + return v +} + +// IntSetIn is MEOS intset_in. +func IntSetIn(str string) (*Set, error) { + _r0, _err := functions.IntsetIn(str) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS intset_out. +func (x *IntSet) Out() (string, error) { + _r0, _err := functions.IntsetOut(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// IntSetMake is MEOS intset_make. +func IntSetMake(values unsafe.Pointer, count int) (*Set, error) { + _r0, _err := functions.IntsetMake(values, count) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// ToFloatset is MEOS intset_to_floatset. +func (x *IntSet) ToFloatset() (*Set, error) { + _r0, _err := functions.IntsetToFloatset(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS intset_end_value. +func (x *IntSet) EndValue() (int, error) { + _r0, _err := functions.IntsetEndValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// StartValue is MEOS intset_start_value. +func (x *IntSet) StartValue() (int, error) { + _r0, _err := functions.IntsetStartValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ValueN is MEOS intset_value_n. +func (x *IntSet) ValueN(n int) (int, bool, error) { + _found, _value, _err := functions.IntsetValueN(functions.SetFromPointer(x.Pointer()), n) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// Values is MEOS intset_values. +func (x *IntSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.IntsetValues(functions.SetFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// ShiftScale is MEOS intset_shift_scale. +func (x *IntSet) ShiftScale(shift int, width int, hasshift bool, haswidth bool) (*Set, error) { + _r0, _err := functions.IntsetShiftScale(functions.SetFromPointer(x.Pointer()), shift, width, hasshift, haswidth) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} diff --git a/types/intspan.go b/types/intspan.go new file mode 100644 index 0000000..a40fa7c --- /dev/null +++ b/types/intspan.go @@ -0,0 +1,123 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type IntSpan struct { + Span +} + +// IntSpanFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func IntSpanFromPointer(p unsafe.Pointer) *IntSpan { + if p == nil { + return nil + } + v := &IntSpan{} + v.ptr = p + return v +} + +// Expand is MEOS intspan_expand. +func (x *IntSpan) Expand(value int32) (*Span, error) { + _r0, _err := functions.IntspanExpand(functions.SpanFromPointer(x.Pointer()), value) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// IntSpanIn is MEOS intspan_in. +func IntSpanIn(str string) (*Span, error) { + _r0, _err := functions.IntspanIn(str) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS intspan_out. +func (x *IntSpan) Out() (string, error) { + _r0, _err := functions.IntspanOut(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// IntSpanMake is MEOS intspan_make. +func IntSpanMake(lower int, upper int, lower_inc bool, upper_inc bool) (*Span, error) { + _r0, _err := functions.IntspanMake(lower, upper, lower_inc, upper_inc) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// ToFloatspan is MEOS intspan_to_floatspan. +func (x *IntSpan) ToFloatspan() (*Span, error) { + _r0, _err := functions.IntspanToFloatspan(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// ToBigintspan is MEOS intspan_to_bigintspan. +func (x *IntSpan) ToBigintspan() (*Span, error) { + _r0, _err := functions.IntspanToBigintspan(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Lower is MEOS intspan_lower. +func (x *IntSpan) Lower() (int, error) { + _r0, _err := functions.IntspanLower(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Upper is MEOS intspan_upper. +func (x *IntSpan) Upper() (int, error) { + _r0, _err := functions.IntspanUpper(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Width is MEOS intspan_width. +func (x *IntSpan) Width() (int, error) { + _r0, _err := functions.IntspanWidth(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ShiftScale is MEOS intspan_shift_scale. +func (x *IntSpan) ShiftScale(shift int, width int, hasshift bool, haswidth bool) (*Span, error) { + _r0, _err := functions.IntspanShiftScale(functions.SpanFromPointer(x.Pointer()), shift, width, hasshift, haswidth) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Bins is MEOS intspan_bins. +func (x *IntSpan) Bins(vsize int, vorigin int, count unsafe.Pointer) (*Span, error) { + _r0, _err := functions.IntspanBins(functions.SpanFromPointer(x.Pointer()), vsize, vorigin, count) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} diff --git a/types/intspanset.go b/types/intspanset.go new file mode 100644 index 0000000..4aa9aaf --- /dev/null +++ b/types/intspanset.go @@ -0,0 +1,96 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type IntSpanSet struct { + SpanSet +} + +// IntSpanSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func IntSpanSetFromPointer(p unsafe.Pointer) *IntSpanSet { + if p == nil { + return nil + } + v := &IntSpanSet{} + v.ptr = p + return v +} + +// IntSpanSetIn is MEOS intspanset_in. +func IntSpanSetIn(str string) (*SpanSet, error) { + _r0, _err := functions.IntspansetIn(str) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS intspanset_out. +func (x *IntSpanSet) Out() (string, error) { + _r0, _err := functions.IntspansetOut(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// ToFloatspanset is MEOS intspanset_to_floatspanset. +func (x *IntSpanSet) ToFloatspanset() (*SpanSet, error) { + _r0, _err := functions.IntspansetToFloatspanset(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// Lower is MEOS intspanset_lower. +func (x *IntSpanSet) Lower() (int, error) { + _r0, _err := functions.IntspansetLower(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Upper is MEOS intspanset_upper. +func (x *IntSpanSet) Upper() (int, error) { + _r0, _err := functions.IntspansetUpper(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Width is MEOS intspanset_width. +func (x *IntSpanSet) Width(boundspan bool) (int, error) { + _r0, _err := functions.IntspansetWidth(functions.SpanSetFromPointer(x.Pointer()), boundspan) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ShiftScale is MEOS intspanset_shift_scale. +func (x *IntSpanSet) ShiftScale(shift int, width int, hasshift bool, haswidth bool) (*SpanSet, error) { + _r0, _err := functions.IntspansetShiftScale(functions.SpanSetFromPointer(x.Pointer()), shift, width, hasshift, haswidth) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// Bins is MEOS intspanset_bins. +func (x *IntSpanSet) Bins(vsize int, vorigin int, count unsafe.Pointer) (*Span, error) { + _r0, _err := functions.IntspansetBins(functions.SpanSetFromPointer(x.Pointer()), vsize, vorigin, count) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} diff --git a/types/jsonb.go b/types/jsonb.go new file mode 100644 index 0000000..f18012f --- /dev/null +++ b/types/jsonb.go @@ -0,0 +1,429 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type Jsonb struct { + Value +} + +// JsonbFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func JsonbFromPointer(p unsafe.Pointer) *Jsonb { + if p == nil { + return nil + } + v := &Jsonb{} + v.ptr = p + return v +} + +// JsonbFromText is MEOS jsonb_from_text. +func JsonbFromText(txt string, unique_keys bool) (*Jsonb, error) { + _r0, _err := functions.JsonbFromText(txt, unique_keys) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// JsonbIn is MEOS jsonb_in. +func JsonbIn(str string) (*Jsonb, error) { + _r0, _err := functions.JsonbIn(str) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS jsonb_out. +func (x *Jsonb) Out() (string, error) { + _r0, _err := functions.JsonbOut(functions.JsonbFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// Copy is MEOS jsonb_copy. +func (x *Jsonb) Copy() (*Jsonb, error) { + _r0, _err := functions.JsonbCopy(functions.JsonbFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// JsonbMake is MEOS jsonb_make. +func JsonbMake(keys_vals unsafe.Pointer, count int) (*Jsonb, error) { + _r0, _err := functions.JsonbMake(keys_vals, count) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// JsonbMakeTwoArg is MEOS jsonb_make_two_arg. +func JsonbMakeTwoArg(keys unsafe.Pointer, values unsafe.Pointer, count int) (*Jsonb, error) { + _r0, _err := functions.JsonbMakeTwoArg(keys, values, count) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// ToBool is MEOS jsonb_to_bool. +func (x *Jsonb) ToBool() (bool, error) { + _r0, _err := functions.JsonbToBool(functions.JsonbFromPointer(x.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// ToCstring is MEOS jsonb_to_cstring. +func (x *Jsonb) ToCstring() (string, error) { + _r0, _err := functions.JsonbToCstring(functions.JsonbFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// ToInt16 is MEOS jsonb_to_int16. +func (x *Jsonb) ToInt16() (int16, error) { + _r0, _err := functions.JsonbToInt16(functions.JsonbFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ToInt32 is MEOS jsonb_to_int32. +func (x *Jsonb) ToInt32() (int32, error) { + _r0, _err := functions.JsonbToInt32(functions.JsonbFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ToInt64 is MEOS jsonb_to_int64. +func (x *Jsonb) ToInt64() (int64, error) { + _r0, _err := functions.JsonbToInt64(functions.JsonbFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ToText is MEOS jsonb_to_text. +func (x *Jsonb) ToText() (string, error) { + _r0, _err := functions.JsonbToText(functions.JsonbFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// ArrayElement is MEOS jsonb_array_element. +func (x *Jsonb) ArrayElement(element int) (*Jsonb, error) { + _r0, _err := functions.JsonbArrayElement(functions.JsonbFromPointer(x.Pointer()), element) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// ArrayElementText is MEOS jsonb_array_element_text. +func (x *Jsonb) ArrayElementText(element int) (string, error) { + _r0, _err := functions.JsonbArrayElementText(functions.JsonbFromPointer(x.Pointer()), element) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// ArrayElements is MEOS jsonb_array_elements. +func (x *Jsonb) ArrayElements(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.JsonbArrayElements(functions.JsonbFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// ArrayElementsText is MEOS jsonb_array_elements_text. +func (x *Jsonb) ArrayElementsText(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.JsonbArrayElementsText(functions.JsonbFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// ArrayLength is MEOS jsonb_array_length. +func (x *Jsonb) ArrayLength() (int, error) { + _r0, _err := functions.JsonbArrayLength(functions.JsonbFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Contained is MEOS jsonb_contained. +func (x *Jsonb) Contained(jb2 *Jsonb) (bool, error) { + _r0, _err := functions.JsonbContained(functions.JsonbFromPointer(x.Pointer()), functions.JsonbFromPointer(jb2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Each is MEOS jsonb_each. +func (x *Jsonb) Each(values unsafe.Pointer, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.JsonbEach(functions.JsonbFromPointer(x.Pointer()), values, count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// EachText is MEOS jsonb_each_text. +func (x *Jsonb) EachText(values unsafe.Pointer, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.JsonbEachText(functions.JsonbFromPointer(x.Pointer()), values, count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Exists is MEOS jsonb_exists. +func (x *Jsonb) Exists(key string) (bool, error) { + _r0, _err := functions.JsonbExists(functions.JsonbFromPointer(x.Pointer()), key) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// ExistsArray is MEOS jsonb_exists_array. +func (x *Jsonb) ExistsArray(keys_elems unsafe.Pointer, keys_len int, any bool) (bool, error) { + _r0, _err := functions.JsonbExistsArray(functions.JsonbFromPointer(x.Pointer()), keys_elems, keys_len, any) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// ExtractPath is MEOS jsonb_extract_path. +func (x *Jsonb) ExtractPath(path_elems unsafe.Pointer, path_len int) (*Jsonb, error) { + _r0, _err := functions.JsonbExtractPath(functions.JsonbFromPointer(x.Pointer()), path_elems, path_len) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// ExtractPathText is MEOS jsonb_extract_path_text. +func (x *Jsonb) ExtractPathText(path_elems unsafe.Pointer, path_len int) (string, error) { + _r0, _err := functions.JsonbExtractPathText(functions.JsonbFromPointer(x.Pointer()), path_elems, path_len) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// Hash is MEOS jsonb_hash. +func (x *Jsonb) Hash() (uint32, error) { + _r0, _err := functions.JsonbHash(functions.JsonbFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// HashExtended is MEOS jsonb_hash_extended. +func (x *Jsonb) HashExtended(seed uint64) (uint64, error) { + _r0, _err := functions.JsonbHashExtended(functions.JsonbFromPointer(x.Pointer()), seed) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ObjectField is MEOS jsonb_object_field. +func (x *Jsonb) ObjectField(key string) (*Jsonb, error) { + _r0, _err := functions.JsonbObjectField(functions.JsonbFromPointer(x.Pointer()), key) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// ObjectFieldText is MEOS jsonb_object_field_text. +func (x *Jsonb) ObjectFieldText(key string) (string, error) { + _r0, _err := functions.JsonbObjectFieldText(functions.JsonbFromPointer(x.Pointer()), key) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// ObjectKeys is MEOS jsonb_object_keys. +func (x *Jsonb) ObjectKeys(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.JsonbObjectKeys(functions.JsonbFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Concat is MEOS jsonb_concat. +func (x *Jsonb) Concat(jb2 *Jsonb) (*Jsonb, error) { + _r0, _err := functions.JsonbConcat(functions.JsonbFromPointer(x.Pointer()), functions.JsonbFromPointer(jb2.Pointer())) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// Delete is MEOS jsonb_delete. +func (x *Jsonb) Delete(key string) (*Jsonb, error) { + _r0, _err := functions.JsonbDelete(functions.JsonbFromPointer(x.Pointer()), key) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// DeleteArray is MEOS jsonb_delete_array. +func (x *Jsonb) DeleteArray(keys_elems unsafe.Pointer, keys_len int) (*Jsonb, error) { + _r0, _err := functions.JsonbDeleteArray(functions.JsonbFromPointer(x.Pointer()), keys_elems, keys_len) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// DeleteIndex is MEOS jsonb_delete_index. +func (x *Jsonb) DeleteIndex(idx int) (*Jsonb, error) { + _r0, _err := functions.JsonbDeleteIndex(functions.JsonbFromPointer(x.Pointer()), idx) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// DeletePath is MEOS jsonb_delete_path. +func (x *Jsonb) DeletePath(path_elems unsafe.Pointer, path_len int) (*Jsonb, error) { + _r0, _err := functions.JsonbDeletePath(functions.JsonbFromPointer(x.Pointer()), path_elems, path_len) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// Insert is MEOS jsonb_insert. +func (x *Jsonb) Insert(path_elems unsafe.Pointer, path_len int, newjb *Jsonb, after bool) (*Jsonb, error) { + _r0, _err := functions.JsonbInsert(functions.JsonbFromPointer(x.Pointer()), path_elems, path_len, functions.JsonbFromPointer(newjb.Pointer()), after) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// Pretty is MEOS jsonb_pretty. +func (x *Jsonb) Pretty() (string, error) { + _r0, _err := functions.JsonbPretty(functions.JsonbFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// Set is MEOS jsonb_set. +func (x *Jsonb) Set(path_elems unsafe.Pointer, path_len int, newjb *Jsonb, create bool) (*Jsonb, error) { + _r0, _err := functions.JsonbSet(functions.JsonbFromPointer(x.Pointer()), path_elems, path_len, functions.JsonbFromPointer(newjb.Pointer()), create) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// SetLax is MEOS jsonb_set_lax. +func (x *Jsonb) SetLax(path_elems unsafe.Pointer, path_len int, newjb *Jsonb, create bool, handle_null string) (*Jsonb, error) { + _r0, _err := functions.JsonbSetLax(functions.JsonbFromPointer(x.Pointer()), path_elems, path_len, functions.JsonbFromPointer(newjb.Pointer()), create, handle_null) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// StripNulls is MEOS jsonb_strip_nulls. +func (x *Jsonb) StripNulls(strip_in_arrays bool) (*Jsonb, error) { + _r0, _err := functions.JsonbStripNulls(functions.JsonbFromPointer(x.Pointer()), strip_in_arrays) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// PathExists is MEOS jsonb_path_exists. +func (x *Jsonb) PathExists(jp *JsonPath, vars *Jsonb, silent bool, tz bool) (int, error) { + _r0, _err := functions.JsonbPathExists(functions.JsonbFromPointer(x.Pointer()), functions.JsonPathFromPointer(jp.Pointer()), functions.JsonbFromPointer(vars.Pointer()), silent, tz) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// PathMatch is MEOS jsonb_path_match. +func (x *Jsonb) PathMatch(jp *JsonPath, vars *Jsonb, silent bool, tz bool) (bool, error) { + _r0, _err := functions.JsonbPathMatch(functions.JsonbFromPointer(x.Pointer()), functions.JsonPathFromPointer(jp.Pointer()), functions.JsonbFromPointer(vars.Pointer()), silent, tz) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// PathQueryAll is MEOS jsonb_path_query_all. +func (x *Jsonb) PathQueryAll(jp *JsonPath, vars *Jsonb, silent bool, tz bool, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.JsonbPathQueryAll(functions.JsonbFromPointer(x.Pointer()), functions.JsonPathFromPointer(jp.Pointer()), functions.JsonbFromPointer(vars.Pointer()), silent, tz, count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// PathQueryArray is MEOS jsonb_path_query_array. +func (x *Jsonb) PathQueryArray(jp *JsonPath, vars *Jsonb, silent bool, tz bool) (*Jsonb, error) { + _r0, _err := functions.JsonbPathQueryArray(functions.JsonbFromPointer(x.Pointer()), functions.JsonPathFromPointer(jp.Pointer()), functions.JsonbFromPointer(vars.Pointer()), silent, tz) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// PathQueryFirst is MEOS jsonb_path_query_first. +func (x *Jsonb) PathQueryFirst(jp *JsonPath, vars *Jsonb, silent bool, tz bool) (*Jsonb, error) { + _r0, _err := functions.JsonbPathQueryFirst(functions.JsonbFromPointer(x.Pointer()), functions.JsonPathFromPointer(jp.Pointer()), functions.JsonbFromPointer(vars.Pointer()), silent, tz) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// ToSet is MEOS jsonb_to_set. +func (x *Jsonb) ToSet() (*Set, error) { + _r0, _err := functions.JsonbToSet(functions.JsonbFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} diff --git a/types/jsonpath.go b/types/jsonpath.go new file mode 100644 index 0000000..8af2c65 --- /dev/null +++ b/types/jsonpath.go @@ -0,0 +1,51 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type JsonPath struct { + Value +} + +// JsonPathFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func JsonPathFromPointer(p unsafe.Pointer) *JsonPath { + if p == nil { + return nil + } + v := &JsonPath{} + v.ptr = p + return v +} + +// JsonPathIn is MEOS jsonpath_in. +func JsonPathIn(str string) (*JsonPath, error) { + _r0, _err := functions.JsonpathIn(str) + if _err != nil { + return nil, _err + } + return JsonPathFromPointer(_r0.Pointer()), nil +} + +// Copy is MEOS jsonpath_copy. +func (x *JsonPath) Copy() (*JsonPath, error) { + _r0, _err := functions.JsonpathCopy(functions.JsonPathFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return JsonPathFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS jsonpath_out. +func (x *JsonPath) Out() (string, error) { + _r0, _err := functions.JsonpathOut(functions.JsonPathFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} diff --git a/types/meos.go b/types/meos.go new file mode 100644 index 0000000..0c925fb --- /dev/null +++ b/types/meos.go @@ -0,0 +1,23 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import "unsafe" + +// handle is the MEOS value every class in this package stands for. +// +// cgo types are package-scoped, so the *C.Temporal the functions package +// holds and one declared here would be DIFFERENT Go types. The untyped +// pointer is the only currency the two packages share, which is why each +// class carries one and hands it across at every call. +type handle struct { + ptr unsafe.Pointer +} + +// Pointer answers the MEOS value this handle stands for, or nil. +func (h *handle) Pointer() unsafe.Pointer { + if h == nil { + return nil + } + return h.ptr +} diff --git a/types/meosarray.go b/types/meosarray.go new file mode 100644 index 0000000..5df69ca --- /dev/null +++ b/types/meosarray.go @@ -0,0 +1,76 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type MeosArray struct { + Value +} + +// MeosArrayFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func MeosArrayFromPointer(p unsafe.Pointer) *MeosArray { + if p == nil { + return nil + } + v := &MeosArray{} + v.ptr = p + return v +} + +// MeosArrayCreate is MEOS meos_array_create. +func MeosArrayCreate(elem_size int) (*MeosArray, error) { + _r0, _err := functions.MeosArrayCreate(elem_size) + if _err != nil { + return nil, _err + } + return MeosArrayFromPointer(_r0.Pointer()), nil +} + +// Add is MEOS meos_array_add. +func (x *MeosArray) Add(value unsafe.Pointer) error { + return functions.MeosArrayAdd(functions.MeosArrayFromPointer(x.Pointer()), value) +} + +// Get is MEOS meos_array_get. +func (x *MeosArray) Get(n int) (unsafe.Pointer, error) { + _r0, _err := functions.MeosArrayGet(functions.MeosArrayFromPointer(x.Pointer()), n) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Count is MEOS meos_array_count. +func (x *MeosArray) Count() (int, error) { + _r0, _err := functions.MeosArrayCount(functions.MeosArrayFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Reset is MEOS meos_array_reset. +func (x *MeosArray) Reset() error { + return functions.MeosArrayReset(functions.MeosArrayFromPointer(x.Pointer())) +} + +// ResetFree is MEOS meos_array_reset_free. +func (x *MeosArray) ResetFree() error { + return functions.MeosArrayResetFree(functions.MeosArrayFromPointer(x.Pointer())) +} + +// Destroy is MEOS meos_array_destroy. +func (x *MeosArray) Destroy() error { + return functions.MeosArrayDestroy(functions.MeosArrayFromPointer(x.Pointer())) +} + +// DestroyFree is MEOS meos_array_destroy_free. +func (x *MeosArray) DestroyFree() error { + return functions.MeosArrayDestroyFree(functions.MeosArrayFromPointer(x.Pointer())) +} diff --git a/types/npoint.go b/types/npoint.go new file mode 100644 index 0000000..3c40f63 --- /dev/null +++ b/types/npoint.go @@ -0,0 +1,285 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type Npoint struct { + Value +} + +// NpointFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func NpointFromPointer(p unsafe.Pointer) *Npoint { + if p == nil { + return nil + } + v := &Npoint{} + v.ptr = p + return v +} + +// AsEWKT is MEOS npoint_as_ewkt. +func (x *Npoint) AsEWKT(maxdd int) (string, error) { + _r0, _err := functions.NpointAsEWKT(functions.NpointFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// 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) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// AsText is MEOS npoint_as_text. +func (x *Npoint) AsText(maxdd int) (string, error) { + _r0, _err := functions.NpointAsText(functions.NpointFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// 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) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// NpointFromHEXWKB is MEOS npoint_from_hexwkb. +func NpointFromHEXWKB(hexwkb string) (*Npoint, error) { + _r0, _err := functions.NpointFromHexwkb(hexwkb) + if _err != nil { + return nil, _err + } + return NpointFromPointer(_r0.Pointer()), nil +} + +// NpointFromWKB is MEOS npoint_from_wkb. +func NpointFromWKB(wkb unsafe.Pointer, size uint) (*Npoint, error) { + _r0, _err := functions.NpointFromWKB(wkb, size) + if _err != nil { + return nil, _err + } + return NpointFromPointer(_r0.Pointer()), nil +} + +// NpointIn is MEOS npoint_in. +func NpointIn(str string) (*Npoint, error) { + _r0, _err := functions.NpointIn(str) + if _err != nil { + return nil, _err + } + return NpointFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS npoint_out. +func (x *Npoint) Out(maxdd int) (string, error) { + _r0, _err := functions.NpointOut(functions.NpointFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// NpointMake is MEOS npoint_make. +func NpointMake(rid int64, pos float64) (*Npoint, error) { + _r0, _err := functions.NpointMake(rid, pos) + if _err != nil { + return nil, _err + } + return NpointFromPointer(_r0.Pointer()), nil +} + +// ToGeompoint is MEOS npoint_to_geompoint. +func (x *Npoint) ToGeompoint() (*TRGeometrySeqSet, error) { + _r0, _err := functions.NpointToGeompoint(functions.NpointFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// ToNsegment is MEOS npoint_to_nsegment. +func (x *Npoint) ToNsegment() (*Nsegment, error) { + _r0, _err := functions.NpointToNsegment(functions.NpointFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return NsegmentFromPointer(_r0.Pointer()), nil +} + +// ToStbox is MEOS npoint_to_stbox. +func (x *Npoint) ToStbox() (*STBox, error) { + _r0, _err := functions.NpointToSTBOX(functions.NpointFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// Hash is MEOS npoint_hash. +func (x *Npoint) Hash() (uint32, error) { + _r0, _err := functions.NpointHash(functions.NpointFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// HashExtended is MEOS npoint_hash_extended. +func (x *Npoint) HashExtended(seed uint64) (uint64, error) { + _r0, _err := functions.NpointHashExtended(functions.NpointFromPointer(x.Pointer()), seed) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Position is MEOS npoint_position. +func (x *Npoint) Position() (float64, error) { + _r0, _err := functions.NpointPosition(functions.NpointFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Route is MEOS npoint_route. +func (x *Npoint) Route() (int64, error) { + _r0, _err := functions.NpointRoute(functions.NpointFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Round is MEOS npoint_round. +func (x *Npoint) Round(maxdd int) (*Npoint, error) { + _r0, _err := functions.NpointRound(functions.NpointFromPointer(x.Pointer()), maxdd) + if _err != nil { + return nil, _err + } + return NpointFromPointer(_r0.Pointer()), nil +} + +// SRID is MEOS npoint_srid. +func (x *Npoint) SRID() (int32, error) { + _r0, _err := functions.NpointSRID(functions.NpointFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// TimestamptzToStbox is MEOS npoint_timestamptz_to_stbox. +func (x *Npoint) TimestamptzToStbox(t int64) (*STBox, error) { + _r0, _err := functions.NpointTimestamptzToSTBOX(functions.NpointFromPointer(x.Pointer()), t) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// TstzspanToStbox is MEOS npoint_tstzspan_to_stbox. +func (x *Npoint) TstzspanToStbox(s *Span) (*STBox, error) { + _r0, _err := functions.NpointTstzspanToSTBOX(functions.NpointFromPointer(x.Pointer()), functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// Cmp is MEOS npoint_cmp. +func (x *Npoint) Cmp(np2 *Npoint) (int, error) { + _r0, _err := functions.NpointCmp(functions.NpointFromPointer(x.Pointer()), functions.NpointFromPointer(np2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Eq is MEOS npoint_eq. +func (x *Npoint) Eq(np2 *Npoint) (bool, error) { + _r0, _err := functions.NpointEq(functions.NpointFromPointer(x.Pointer()), functions.NpointFromPointer(np2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Ge is MEOS npoint_ge. +func (x *Npoint) Ge(np2 *Npoint) (bool, error) { + _r0, _err := functions.NpointGe(functions.NpointFromPointer(x.Pointer()), functions.NpointFromPointer(np2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Gt is MEOS npoint_gt. +func (x *Npoint) Gt(np2 *Npoint) (bool, error) { + _r0, _err := functions.NpointGt(functions.NpointFromPointer(x.Pointer()), functions.NpointFromPointer(np2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Le is MEOS npoint_le. +func (x *Npoint) Le(np2 *Npoint) (bool, error) { + _r0, _err := functions.NpointLe(functions.NpointFromPointer(x.Pointer()), functions.NpointFromPointer(np2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Lt is MEOS npoint_lt. +func (x *Npoint) Lt(np2 *Npoint) (bool, error) { + _r0, _err := functions.NpointLt(functions.NpointFromPointer(x.Pointer()), functions.NpointFromPointer(np2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Ne is MEOS npoint_ne. +func (x *Npoint) Ne(np2 *Npoint) (bool, error) { + _r0, _err := functions.NpointNe(functions.NpointFromPointer(x.Pointer()), functions.NpointFromPointer(np2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Same is MEOS npoint_same. +func (x *Npoint) Same(np2 *Npoint) (bool, error) { + _r0, _err := functions.NpointSame(functions.NpointFromPointer(x.Pointer()), functions.NpointFromPointer(np2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// ToSet is MEOS npoint_to_set. +func (x *Npoint) ToSet() (*Set, error) { + _r0, _err := functions.NpointToSet(functions.NpointFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} diff --git a/types/npointset.go b/types/npointset.go new file mode 100644 index 0000000..6720a7c --- /dev/null +++ b/types/npointset.go @@ -0,0 +1,99 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type NpointSet struct { + Set +} + +// NpointSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func NpointSetFromPointer(p unsafe.Pointer) *NpointSet { + if p == nil { + return nil + } + v := &NpointSet{} + v.ptr = p + return v +} + +// NpointSetIn is MEOS npointset_in. +func NpointSetIn(str string) (*Set, error) { + _r0, _err := functions.NpointsetIn(str) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS npointset_out. +func (x *NpointSet) Out(maxdd int) (string, error) { + _r0, _err := functions.NpointsetOut(functions.SetFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// NpointSetMake is MEOS npointset_make. +func NpointSetMake(values unsafe.Pointer, count int) (*Set, error) { + _r0, _err := functions.NpointsetMake(values, count) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS npointset_end_value. +func (x *NpointSet) EndValue() (*Npoint, error) { + _r0, _err := functions.NpointsetEndValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return NpointFromPointer(_r0.Pointer()), nil +} + +// Routes is MEOS npointset_routes. +func (x *NpointSet) Routes() (*Set, error) { + _r0, _err := functions.NpointsetRoutes(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// StartValue is MEOS npointset_start_value. +func (x *NpointSet) StartValue() (*Npoint, error) { + _r0, _err := functions.NpointsetStartValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return NpointFromPointer(_r0.Pointer()), nil +} + +// ValueN is MEOS npointset_value_n. +func (x *NpointSet) ValueN(n int) (*Npoint, bool, error) { + _found, _value, _err := functions.NpointsetValueN(functions.SetFromPointer(x.Pointer()), n) + if _err != nil { + return nil, false, _err + } + if !_found { + return nil, false, nil + } + return NpointFromPointer(_value.Pointer()), true, nil +} + +// Values is MEOS npointset_values. +func (x *NpointSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.NpointsetValues(functions.SetFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} diff --git a/types/nsegment.go b/types/nsegment.go new file mode 100644 index 0000000..63d9521 --- /dev/null +++ b/types/nsegment.go @@ -0,0 +1,177 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type Nsegment struct { + Value +} + +// NsegmentFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func NsegmentFromPointer(p unsafe.Pointer) *Nsegment { + if p == nil { + return nil + } + v := &Nsegment{} + v.ptr = p + return v +} + +// NsegmentIn is MEOS nsegment_in. +func NsegmentIn(str string) (*Nsegment, error) { + _r0, _err := functions.NsegmentIn(str) + if _err != nil { + return nil, _err + } + return NsegmentFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS nsegment_out. +func (x *Nsegment) Out(maxdd int) (string, error) { + _r0, _err := functions.NsegmentOut(functions.NsegmentFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// NsegmentMake is MEOS nsegment_make. +func NsegmentMake(rid int64, pos1 float64, pos2 float64) (*Nsegment, error) { + _r0, _err := functions.NsegmentMake(rid, pos1, pos2) + if _err != nil { + return nil, _err + } + return NsegmentFromPointer(_r0.Pointer()), nil +} + +// ToGeom is MEOS nsegment_to_geom. +func (x *Nsegment) ToGeom() (*TRGeometrySeqSet, error) { + _r0, _err := functions.NsegmentToGeom(functions.NsegmentFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// ToStbox is MEOS nsegment_to_stbox. +func (x *Nsegment) ToStbox() (*STBox, error) { + _r0, _err := functions.NsegmentToSTBOX(functions.NsegmentFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// EndPosition is MEOS nsegment_end_position. +func (x *Nsegment) EndPosition() (float64, error) { + _r0, _err := functions.NsegmentEndPosition(functions.NsegmentFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Route is MEOS nsegment_route. +func (x *Nsegment) Route() (int64, error) { + _r0, _err := functions.NsegmentRoute(functions.NsegmentFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// StartPosition is MEOS nsegment_start_position. +func (x *Nsegment) StartPosition() (float64, error) { + _r0, _err := functions.NsegmentStartPosition(functions.NsegmentFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Round is MEOS nsegment_round. +func (x *Nsegment) Round(maxdd int) (*Nsegment, error) { + _r0, _err := functions.NsegmentRound(functions.NsegmentFromPointer(x.Pointer()), maxdd) + if _err != nil { + return nil, _err + } + return NsegmentFromPointer(_r0.Pointer()), nil +} + +// SRID is MEOS nsegment_srid. +func (x *Nsegment) SRID() (int32, error) { + _r0, _err := functions.NsegmentSRID(functions.NsegmentFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Cmp is MEOS nsegment_cmp. +func (x *Nsegment) Cmp(ns2 *Nsegment) (int, error) { + _r0, _err := functions.NsegmentCmp(functions.NsegmentFromPointer(x.Pointer()), functions.NsegmentFromPointer(ns2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Eq is MEOS nsegment_eq. +func (x *Nsegment) Eq(ns2 *Nsegment) (bool, error) { + _r0, _err := functions.NsegmentEq(functions.NsegmentFromPointer(x.Pointer()), functions.NsegmentFromPointer(ns2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Ge is MEOS nsegment_ge. +func (x *Nsegment) Ge(ns2 *Nsegment) (bool, error) { + _r0, _err := functions.NsegmentGe(functions.NsegmentFromPointer(x.Pointer()), functions.NsegmentFromPointer(ns2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Gt is MEOS nsegment_gt. +func (x *Nsegment) Gt(ns2 *Nsegment) (bool, error) { + _r0, _err := functions.NsegmentGt(functions.NsegmentFromPointer(x.Pointer()), functions.NsegmentFromPointer(ns2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Le is MEOS nsegment_le. +func (x *Nsegment) Le(ns2 *Nsegment) (bool, error) { + _r0, _err := functions.NsegmentLe(functions.NsegmentFromPointer(x.Pointer()), functions.NsegmentFromPointer(ns2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Lt is MEOS nsegment_lt. +func (x *Nsegment) Lt(ns2 *Nsegment) (bool, error) { + _r0, _err := functions.NsegmentLt(functions.NsegmentFromPointer(x.Pointer()), functions.NsegmentFromPointer(ns2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Ne is MEOS nsegment_ne. +func (x *Nsegment) Ne(ns2 *Nsegment) (bool, error) { + _r0, _err := functions.NsegmentNe(functions.NsegmentFromPointer(x.Pointer()), functions.NsegmentFromPointer(ns2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} diff --git a/types/pcpatch.go b/types/pcpatch.go new file mode 100644 index 0000000..1ca4211 --- /dev/null +++ b/types/pcpatch.go @@ -0,0 +1,177 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type Pcpatch struct { + Value +} + +// PcpatchFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func PcpatchFromPointer(p unsafe.Pointer) *Pcpatch { + if p == nil { + return nil + } + v := &Pcpatch{} + v.ptr = p + return v +} + +// PcpatchHexIn is MEOS pcpatch_hex_in. +func PcpatchHexIn(str string) (*Pcpatch, error) { + _r0, _err := functions.PcpatchHexIn(str) + if _err != nil { + return nil, _err + } + return PcpatchFromPointer(_r0.Pointer()), nil +} + +// HexOut is MEOS pcpatch_hex_out. +func (x *Pcpatch) HexOut(maxdd int) (string, error) { + _r0, _err := functions.PcpatchHexOut(functions.PcpatchFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// PcpatchFromHEXWKB is MEOS pcpatch_from_hexwkb. +func PcpatchFromHEXWKB(hexwkb string) (*Pcpatch, error) { + _r0, _err := functions.PcpatchFromHexwkb(hexwkb) + if _err != nil { + return nil, _err + } + return PcpatchFromPointer(_r0.Pointer()), nil +} + +// AsHEXWKB is MEOS pcpatch_as_hexwkb. +func (x *Pcpatch) AsHEXWKB() (string, error) { + _r0, _err := functions.PcpatchAsHexwkb(functions.PcpatchFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// PcpatchMake is MEOS pcpatch_make. +func PcpatchMake(points unsafe.Pointer, count int) (*Pcpatch, error) { + _r0, _err := functions.PcpatchMake(points, count) + if _err != nil { + return nil, _err + } + return PcpatchFromPointer(_r0.Pointer()), nil +} + +// PcpatchMakeCoords is MEOS pcpatch_make_coords. +func PcpatchMakeCoords(pcid uint32, values unsafe.Pointer, count int) (*Pcpatch, error) { + _r0, _err := functions.PcpatchMakeCoords(pcid, values, count) + if _err != nil { + return nil, _err + } + return PcpatchFromPointer(_r0.Pointer()), nil +} + +// Copy is MEOS pcpatch_copy. +func (x *Pcpatch) Copy() (*Pcpatch, error) { + _r0, _err := functions.PcpatchCopy(functions.PcpatchFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return PcpatchFromPointer(_r0.Pointer()), nil +} + +// GetPcid is MEOS pcpatch_get_pcid. +func (x *Pcpatch) GetPcid() (uint32, error) { + _r0, _err := functions.PcpatchGetPcid(functions.PcpatchFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Npoints is MEOS pcpatch_npoints. +func (x *Pcpatch) Npoints() (uint32, error) { + _r0, _err := functions.PcpatchNpoints(functions.PcpatchFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// PointN is MEOS pcpatch_point_n. +func (x *Pcpatch) PointN(n int) (*Pcpoint, error) { + _r0, _err := functions.PcpatchPointN(functions.PcpatchFromPointer(x.Pointer()), n) + if _err != nil { + return nil, _err + } + return PcpointFromPointer(_r0.Pointer()), nil +} + +// Points is MEOS pcpatch_points. +func (x *Pcpatch) Points(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.PcpatchPoints(functions.PcpatchFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Hash is MEOS pcpatch_hash. +func (x *Pcpatch) Hash() (uint32, error) { + _r0, _err := functions.PcpatchHash(functions.PcpatchFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// HashExtended is MEOS pcpatch_hash_extended. +func (x *Pcpatch) HashExtended(seed uint64) (uint64, error) { + _r0, _err := functions.PcpatchHashExtended(functions.PcpatchFromPointer(x.Pointer()), seed) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ToGeom is MEOS pcpatch_to_geom. +func (x *Pcpatch) ToGeom() (*TRGeometrySeqSet, error) { + _r0, _err := functions.PcpatchToGeom(functions.PcpatchFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// Cmp is MEOS pcpatch_cmp. +func (x *Pcpatch) Cmp(pa2 *Pcpatch) (int, error) { + _r0, _err := functions.PcpatchCmp(functions.PcpatchFromPointer(x.Pointer()), functions.PcpatchFromPointer(pa2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ToSet is MEOS pcpatch_to_set. +func (x *Pcpatch) ToSet() (*Set, error) { + _r0, _err := functions.PcpatchToSet(functions.PcpatchFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// ToTpcbox is MEOS pcpatch_to_tpcbox. +func (x *Pcpatch) ToTpcbox(srid int32) (*TPCBox, error) { + _r0, _err := functions.PcpatchToTpcbox(functions.PcpatchFromPointer(x.Pointer()), srid) + if _err != nil { + return nil, _err + } + return TPCBoxFromPointer(_r0.Pointer()), nil +} diff --git a/types/pcpoint.go b/types/pcpoint.go new file mode 100644 index 0000000..9bb8f45 --- /dev/null +++ b/types/pcpoint.go @@ -0,0 +1,168 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type Pcpoint struct { + Value +} + +// PcpointFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func PcpointFromPointer(p unsafe.Pointer) *Pcpoint { + if p == nil { + return nil + } + v := &Pcpoint{} + v.ptr = p + return v +} + +// PcpointHexIn is MEOS pcpoint_hex_in. +func PcpointHexIn(str string) (*Pcpoint, error) { + _r0, _err := functions.PcpointHexIn(str) + if _err != nil { + return nil, _err + } + return PcpointFromPointer(_r0.Pointer()), nil +} + +// HexOut is MEOS pcpoint_hex_out. +func (x *Pcpoint) HexOut(maxdd int) (string, error) { + _r0, _err := functions.PcpointHexOut(functions.PcpointFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// PcpointFromHEXWKB is MEOS pcpoint_from_hexwkb. +func PcpointFromHEXWKB(hexwkb string) (*Pcpoint, error) { + _r0, _err := functions.PcpointFromHexwkb(hexwkb) + if _err != nil { + return nil, _err + } + return PcpointFromPointer(_r0.Pointer()), nil +} + +// AsHEXWKB is MEOS pcpoint_as_hexwkb. +func (x *Pcpoint) AsHEXWKB() (string, error) { + _r0, _err := functions.PcpointAsHexwkb(functions.PcpointFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// PcpointMake is MEOS pcpoint_make. +func PcpointMake(pcid uint32, values unsafe.Pointer, count int) (*Pcpoint, error) { + _r0, _err := functions.PcpointMake(pcid, values, count) + if _err != nil { + return nil, _err + } + return PcpointFromPointer(_r0.Pointer()), nil +} + +// Copy is MEOS pcpoint_copy. +func (x *Pcpoint) Copy() (*Pcpoint, error) { + _r0, _err := functions.PcpointCopy(functions.PcpointFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return PcpointFromPointer(_r0.Pointer()), nil +} + +// GetPcid is MEOS pcpoint_get_pcid. +func (x *Pcpoint) GetPcid() (uint32, error) { + _r0, _err := functions.PcpointGetPcid(functions.PcpointFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Hash is MEOS pcpoint_hash. +func (x *Pcpoint) Hash() (uint32, error) { + _r0, _err := functions.PcpointHash(functions.PcpointFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// HashExtended is MEOS pcpoint_hash_extended. +func (x *Pcpoint) HashExtended(seed uint64) (uint64, error) { + _r0, _err := functions.PcpointHashExtended(functions.PcpointFromPointer(x.Pointer()), seed) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// GetX is MEOS pcpoint_get_x. +func (x *Pcpoint) GetX(schema *Pcschema, out unsafe.Pointer) (bool, error) { + _r0, _err := functions.PcpointGetX(functions.PcpointFromPointer(x.Pointer()), functions.PCSchemaFromPointer(schema.Pointer()), out) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// GetY is MEOS pcpoint_get_y. +func (x *Pcpoint) GetY(schema *Pcschema, out unsafe.Pointer) (bool, error) { + _r0, _err := functions.PcpointGetY(functions.PcpointFromPointer(x.Pointer()), functions.PCSchemaFromPointer(schema.Pointer()), out) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// GetZ is MEOS pcpoint_get_z. +func (x *Pcpoint) GetZ(schema *Pcschema, out unsafe.Pointer) (bool, error) { + _r0, _err := functions.PcpointGetZ(functions.PcpointFromPointer(x.Pointer()), functions.PCSchemaFromPointer(schema.Pointer()), out) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// GetDim is MEOS pcpoint_get_dim. +func (x *Pcpoint) GetDim(schema *Pcschema, name string, out unsafe.Pointer) (bool, error) { + _r0, _err := functions.PcpointGetDim(functions.PcpointFromPointer(x.Pointer()), functions.PCSchemaFromPointer(schema.Pointer()), name, out) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// ToTpcbox is MEOS pcpoint_to_tpcbox. +func (x *Pcpoint) ToTpcbox(schema *Pcschema) (*TPCBox, error) { + _r0, _err := functions.PcpointToTpcbox(functions.PcpointFromPointer(x.Pointer()), functions.PCSchemaFromPointer(schema.Pointer())) + if _err != nil { + return nil, _err + } + return TPCBoxFromPointer(_r0.Pointer()), nil +} + +// Cmp is MEOS pcpoint_cmp. +func (x *Pcpoint) Cmp(pt2 *Pcpoint) (int, error) { + _r0, _err := functions.PcpointCmp(functions.PcpointFromPointer(x.Pointer()), functions.PcpointFromPointer(pt2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ToSet is MEOS pcpoint_to_set. +func (x *Pcpoint) ToSet() (*Set, error) { + _r0, _err := functions.PcpointToSet(functions.PcpointFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} diff --git a/types/pcschema.go b/types/pcschema.go new file mode 100644 index 0000000..73a5104 --- /dev/null +++ b/types/pcschema.go @@ -0,0 +1,102 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type Pcschema struct { + Value +} + +// PcschemaFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func PcschemaFromPointer(p unsafe.Pointer) *Pcschema { + if p == nil { + return nil + } + v := &Pcschema{} + v.ptr = p + return v +} + +// PcschemaGet is MEOS meos_pc_schema. +func PcschemaGet(pcid uint32) (*Pcschema, error) { + _r0, _err := functions.MeosPcSchema(pcid) + if _err != nil { + return nil, _err + } + return PcschemaFromPointer(_r0.Pointer()), nil +} + +// PcschemaRegister is MEOS meos_pc_schema_register. +func PcschemaRegister(pcid uint32, schema *Pcschema) error { + return functions.MeosPcSchemaRegister(pcid, functions.PCSchemaFromPointer(schema.Pointer())) +} + +// PcschemaFromDims is MEOS meos_pc_schema_from_dims. +func PcschemaFromDims(pcid uint32, srid int32, compression string, dims unsafe.Pointer, ndims int) (*Pcschema, error) { + _r0, _err := functions.MeosPcSchemaFromDims(pcid, srid, compression, dims, ndims) + if _err != nil { + return nil, _err + } + return PcschemaFromPointer(_r0.Pointer()), nil +} + +// PcschemaRegisterDims is MEOS meos_pc_schema_register_dims. +func PcschemaRegisterDims(pcid uint32, srid int32, compression string, dims unsafe.Pointer, ndims int) (bool, error) { + _r0, _err := functions.MeosPcSchemaRegisterDims(pcid, srid, compression, dims, ndims) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// PcschemaRegisterXml is MEOS meos_pc_schema_register_xml. +func PcschemaRegisterXml(pcid uint32, schema *Pcschema, xml_text string) error { + return functions.MeosPcSchemaRegisterXml(pcid, functions.PCSchemaFromPointer(schema.Pointer()), xml_text) +} + +// PcschemaXml is MEOS meos_pc_schema_xml. +func PcschemaXml(pcid uint32) (string, error) { + _r0, _err := functions.MeosPcSchemaXml(pcid) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// PcschemaClear is MEOS meos_pc_schema_clear. +func PcschemaClear() error { + return functions.MeosPcSchemaClear() +} + +// PcschemaSRID is MEOS meos_pc_schema_srid. +func PcschemaSRID(pcid uint32) (int32, error) { + _r0, _err := functions.MeosPcSchemaSRID(pcid) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// PcschemaCompression is MEOS meos_pc_schema_compression. +func PcschemaCompression(pcid uint32) (string, error) { + _r0, _err := functions.MeosPcSchemaCompression(pcid) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// PcschemaNdims is MEOS meos_pc_schema_ndims. +func PcschemaNdims(pcid uint32) (int32, error) { + _r0, _err := functions.MeosPcSchemaNdims(pcid) + if _err != nil { + return 0, _err + } + return _r0, nil +} diff --git a/types/pose.go b/types/pose.go new file mode 100644 index 0000000..982b60d --- /dev/null +++ b/types/pose.go @@ -0,0 +1,465 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type Pose struct { + Value +} + +// PoseFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func PoseFromPointer(p unsafe.Pointer) *Pose { + if p == nil { + return nil + } + v := &Pose{} + v.ptr = p + return v +} + +// AsEWKT is MEOS pose_as_ewkt. +func (x *Pose) AsEWKT(maxdd int) (string, error) { + _r0, _err := functions.PoseAsEWKT(functions.PoseFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// 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) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// AsText is MEOS pose_as_text. +func (x *Pose) AsText(maxdd int) (string, error) { + _r0, _err := functions.PoseAsText(functions.PoseFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// 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) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// PoseFromWKB is MEOS pose_from_wkb. +func PoseFromWKB(wkb unsafe.Pointer, size uint) (*Pose, error) { + _r0, _err := functions.PoseFromWKB(wkb, size) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// PoseFromHEXWKB is MEOS pose_from_hexwkb. +func PoseFromHEXWKB(hexwkb string) (*Pose, error) { + _r0, _err := functions.PoseFromHexwkb(hexwkb) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// PoseIn is MEOS pose_in. +func PoseIn(str string) (*Pose, error) { + _r0, _err := functions.PoseIn(str) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS pose_out. +func (x *Pose) Out(maxdd int) (string, error) { + _r0, _err := functions.PoseOut(functions.PoseFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// PoseFromGeopose is MEOS pose_from_geopose. +func PoseFromGeopose(json string) (*Pose, error) { + _r0, _err := functions.PoseFromGeopose(json) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// AsGeopose is MEOS pose_as_geopose. +func (x *Pose) AsGeopose(conformance int, precision int) (string, error) { + _r0, _err := functions.PoseAsGeopose(functions.PoseFromPointer(x.Pointer()), conformance, precision) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// ApplyGeo is MEOS pose_apply_geo. +func (x *Pose) ApplyGeo(body *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { + _r0, _err := functions.PoseApplyGeo(functions.PoseFromPointer(x.Pointer()), functions.GeomFromPointer(body.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// ComposeTpose is MEOS pose_compose_tpose. +func (x *Pose) ComposeTpose(frame *Temporal) (*Temporal, error) { + _r0, _err := functions.PoseComposeTpose(functions.PoseFromPointer(x.Pointer()), functions.TemporalFromPointer(frame.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Copy is MEOS pose_copy. +func (x *Pose) Copy() (*Pose, error) { + _r0, _err := functions.PoseCopy(functions.PoseFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// PoseMake2d is MEOS pose_make_2d. +func PoseMake2d(x float64, y float64, theta float64, geodetic bool, srid int32) (*Pose, error) { + _r0, _err := functions.PoseMake2d(x, y, theta, geodetic, srid) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// PoseMake3d is MEOS pose_make_3d. +func PoseMake3d(x float64, y float64, z float64, W float64, X float64, Y float64, Z float64, geodetic bool, srid int32) (*Pose, error) { + _r0, _err := functions.PoseMake3d(x, y, z, W, X, Y, Z, geodetic, srid) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// PoseMakePoint2d is MEOS pose_make_point2d. +func PoseMakePoint2d(gs *TRGeometrySeqSet, theta float64) (*Pose, error) { + _r0, _err := functions.PoseMakePoint2d(functions.GeomFromPointer(gs.Pointer()), theta) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// PoseMakePoint3d is MEOS pose_make_point3d. +func PoseMakePoint3d(gs *TRGeometrySeqSet, W float64, X float64, Y float64, Z float64) (*Pose, error) { + _r0, _err := functions.PoseMakePoint3d(functions.GeomFromPointer(gs.Pointer()), W, X, Y, Z) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// PoseMakePoint3dYpr is MEOS pose_make_point3d_ypr. +func PoseMakePoint3dYpr(gs *TRGeometrySeqSet, yaw float64, pitch float64, roll float64) (*Pose, error) { + _r0, _err := functions.PoseMakePoint3dYpr(functions.GeomFromPointer(gs.Pointer()), yaw, pitch, roll) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// ToPoint is MEOS pose_to_point. +func (x *Pose) ToPoint() (*TRGeometrySeqSet, error) { + _r0, _err := functions.PoseToPoint(functions.PoseFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// ToStbox is MEOS pose_to_stbox. +func (x *Pose) ToStbox() (*STBox, error) { + _r0, _err := functions.PoseToSTBOX(functions.PoseFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// Hash is MEOS pose_hash. +func (x *Pose) Hash() (uint32, error) { + _r0, _err := functions.PoseHash(functions.PoseFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// HashExtended is MEOS pose_hash_extended. +func (x *Pose) HashExtended(seed uint64) (uint64, error) { + _r0, _err := functions.PoseHashExtended(functions.PoseFromPointer(x.Pointer()), seed) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Quaternion is MEOS pose_quaternion. +func (x *Pose) Quaternion(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.PoseQuaternion(functions.PoseFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Ypr is MEOS pose_ypr. +func (x *Pose) Ypr(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.PoseYpr(functions.PoseFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Yaw is MEOS pose_yaw. +func (x *Pose) Yaw() (float64, error) { + _r0, _err := functions.PoseYaw(functions.PoseFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Pitch is MEOS pose_pitch. +func (x *Pose) Pitch() (float64, error) { + _r0, _err := functions.PosePitch(functions.PoseFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Roll is MEOS pose_roll. +func (x *Pose) Roll() (float64, error) { + _r0, _err := functions.PoseRoll(functions.PoseFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// AngularDistance is MEOS pose_angular_distance. +func (x *Pose) AngularDistance(pose2 *Pose) (float64, error) { + _r0, _err := functions.PoseAngularDistance(functions.PoseFromPointer(x.Pointer()), functions.PoseFromPointer(pose2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Compose is MEOS pose_compose. +func (x *Pose) Compose(frame *Pose) (*Pose, error) { + _r0, _err := functions.PoseCompose(functions.PoseFromPointer(x.Pointer()), functions.PoseFromPointer(frame.Pointer())) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// Inverse is MEOS pose_inverse. +func (x *Pose) Inverse() (*Pose, error) { + _r0, _err := functions.PoseInverse(functions.PoseFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// Normalize is MEOS pose_normalize. +func (x *Pose) Normalize() (*Pose, error) { + _r0, _err := functions.PoseNormalize(functions.PoseFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// Round is MEOS pose_round. +func (x *Pose) Round(maxdd int) (*Pose, error) { + _r0, _err := functions.PoseRound(functions.PoseFromPointer(x.Pointer()), maxdd) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// SetSRID is MEOS pose_set_srid. +func (x *Pose) SetSRID(srid int32) (*Pose, error) { + _r0, _err := functions.PoseSetSRID(functions.PoseFromPointer(x.Pointer()), srid) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// SRID is MEOS pose_srid. +func (x *Pose) SRID() (int32, error) { + _r0, _err := functions.PoseSRID(functions.PoseFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Transform is MEOS pose_transform. +func (x *Pose) Transform(srid int32) (*Pose, error) { + _r0, _err := functions.PoseTransform(functions.PoseFromPointer(x.Pointer()), srid) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// TransformPipeline is MEOS pose_transform_pipeline. +func (x *Pose) TransformPipeline(pipelinestr string, srid int32, is_forward bool) (*Pose, error) { + _r0, _err := functions.PoseTransformPipeline(functions.PoseFromPointer(x.Pointer()), pipelinestr, srid, is_forward) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// TstzspanToStbox is MEOS pose_tstzspan_to_stbox. +func (x *Pose) TstzspanToStbox(s *Span) (*STBox, error) { + _r0, _err := functions.PoseTstzspanToSTBOX(functions.PoseFromPointer(x.Pointer()), functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// TimestamptzToStbox is MEOS pose_timestamptz_to_stbox. +func (x *Pose) TimestamptzToStbox(t int64) (*STBox, error) { + _r0, _err := functions.PoseTimestamptzToSTBOX(functions.PoseFromPointer(x.Pointer()), t) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// Cmp is MEOS pose_cmp. +func (x *Pose) Cmp(pose2 *Pose) (int, error) { + _r0, _err := functions.PoseCmp(functions.PoseFromPointer(x.Pointer()), functions.PoseFromPointer(pose2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Eq is MEOS pose_eq. +func (x *Pose) Eq(pose2 *Pose) (bool, error) { + _r0, _err := functions.PoseEq(functions.PoseFromPointer(x.Pointer()), functions.PoseFromPointer(pose2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Ge is MEOS pose_ge. +func (x *Pose) Ge(pose2 *Pose) (bool, error) { + _r0, _err := functions.PoseGe(functions.PoseFromPointer(x.Pointer()), functions.PoseFromPointer(pose2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Gt is MEOS pose_gt. +func (x *Pose) Gt(pose2 *Pose) (bool, error) { + _r0, _err := functions.PoseGt(functions.PoseFromPointer(x.Pointer()), functions.PoseFromPointer(pose2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Le is MEOS pose_le. +func (x *Pose) Le(pose2 *Pose) (bool, error) { + _r0, _err := functions.PoseLe(functions.PoseFromPointer(x.Pointer()), functions.PoseFromPointer(pose2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Lt is MEOS pose_lt. +func (x *Pose) Lt(pose2 *Pose) (bool, error) { + _r0, _err := functions.PoseLt(functions.PoseFromPointer(x.Pointer()), functions.PoseFromPointer(pose2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Ne is MEOS pose_ne. +func (x *Pose) Ne(pose2 *Pose) (bool, error) { + _r0, _err := functions.PoseNe(functions.PoseFromPointer(x.Pointer()), functions.PoseFromPointer(pose2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Nsame is MEOS pose_nsame. +func (x *Pose) Nsame(pose2 *Pose) (bool, error) { + _r0, _err := functions.PoseNsame(functions.PoseFromPointer(x.Pointer()), functions.PoseFromPointer(pose2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Same is MEOS pose_same. +func (x *Pose) Same(pose2 *Pose) (bool, error) { + _r0, _err := functions.PoseSame(functions.PoseFromPointer(x.Pointer()), functions.PoseFromPointer(pose2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// ToSet is MEOS pose_to_set. +func (x *Pose) ToSet() (*Set, error) { + _r0, _err := functions.PoseToSet(functions.PoseFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// ToPosechain is MEOS pose_to_posechain. +func (x *Pose) ToPosechain() (unsafe.Pointer, error) { + _r0, _err := functions.PoseToPosechain(functions.PoseFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return _r0, nil +} diff --git a/types/posechain.go b/types/posechain.go new file mode 100644 index 0000000..f070a85 --- /dev/null +++ b/types/posechain.go @@ -0,0 +1,375 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type PoseChain struct { + Value +} + +// PoseChainFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func PoseChainFromPointer(p unsafe.Pointer) *PoseChain { + if p == nil { + return nil + } + v := &PoseChain{} + v.ptr = p + return v +} + +// PoseChainIn is MEOS posechain_in. +func PoseChainIn(str string) (unsafe.Pointer, error) { + _r0, _err := functions.PosechainIn(str) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// PoseChainOut is MEOS posechain_out. +func PoseChainOut(pc unsafe.Pointer, maxdd int) (string, error) { + _r0, _err := functions.PosechainOut(pc, maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// PoseChainAsText is MEOS posechain_as_text. +func PoseChainAsText(pc unsafe.Pointer, maxdd int) (string, error) { + _r0, _err := functions.PosechainAsText(pc, maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// PoseChainAsEWKT is MEOS posechain_as_ewkt. +func PoseChainAsEWKT(pc unsafe.Pointer, maxdd int) (string, error) { + _r0, _err := functions.PosechainAsEWKT(pc, maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// 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) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// 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) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// PoseChainFromWKB is MEOS posechain_from_wkb. +func PoseChainFromWKB(wkb unsafe.Pointer, size uint) (unsafe.Pointer, error) { + _r0, _err := functions.PosechainFromWKB(wkb, size) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// PoseChainFromHEXWKB is MEOS posechain_from_hexwkb. +func PoseChainFromHEXWKB(hexwkb string) (unsafe.Pointer, error) { + _r0, _err := functions.PosechainFromHexwkb(hexwkb) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// PoseChainMake is MEOS posechain_make. +func PoseChainMake(poses unsafe.Pointer, count int) (unsafe.Pointer, error) { + _r0, _err := functions.PosechainMake(poses, count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// PoseChainCopy is MEOS posechain_copy. +func PoseChainCopy(pc unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.PosechainCopy(pc) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// PoseChainAppend is MEOS posechain_append. +func PoseChainAppend(pc unsafe.Pointer, pose *Pose) (unsafe.Pointer, error) { + _r0, _err := functions.PosechainAppend(pc, functions.PoseFromPointer(pose.Pointer())) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// PoseChainToPose is MEOS posechain_to_pose. +func PoseChainToPose(pc unsafe.Pointer) (*Pose, error) { + _r0, _err := functions.PosechainToPose(pc) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// PoseChainPrefixPose is MEOS posechain_prefix_pose. +func PoseChainPrefixPose(pc unsafe.Pointer, n int) (*Pose, error) { + _r0, _err := functions.PosechainPrefixPose(pc, n) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// PoseChainToPoint is MEOS posechain_to_point. +func PoseChainToPoint(pc unsafe.Pointer) (*TRGeometrySeqSet, error) { + _r0, _err := functions.PosechainToPoint(pc) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// PoseChainToStbox is MEOS posechain_to_stbox. +func PoseChainToStbox(pc unsafe.Pointer) (*STBox, error) { + _r0, _err := functions.PosechainToSTBOX(pc) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// PoseChainTimestamptzToStbox is MEOS posechain_timestamptz_to_stbox. +func PoseChainTimestamptzToStbox(pc unsafe.Pointer, t int64) (*STBox, error) { + _r0, _err := functions.PosechainTimestamptzToSTBOX(pc, t) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// PoseChainTstzspanToStbox is MEOS posechain_tstzspan_to_stbox. +func PoseChainTstzspanToStbox(pc unsafe.Pointer, s *Span) (*STBox, error) { + _r0, _err := functions.PosechainTstzspanToSTBOX(pc, functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// PoseChainNumPoses is MEOS posechain_num_poses. +func PoseChainNumPoses(pc unsafe.Pointer) (int, error) { + _r0, _err := functions.PosechainNumPoses(pc) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// PoseChainStartPose is MEOS posechain_start_pose. +func PoseChainStartPose(pc unsafe.Pointer) (*Pose, error) { + _r0, _err := functions.PosechainStartPose(pc) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// PoseChainEndPose is MEOS posechain_end_pose. +func PoseChainEndPose(pc unsafe.Pointer) (*Pose, error) { + _r0, _err := functions.PosechainEndPose(pc) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// PoseChainPoseN is MEOS posechain_pose_n. +func PoseChainPoseN(pc unsafe.Pointer, n int) (*Pose, error) { + _r0, _err := functions.PosechainPoseN(pc, n) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// PoseChainPoses is MEOS posechain_poses. +func PoseChainPoses(pc unsafe.Pointer, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.PosechainPoses(pc, count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// PoseChainHash is MEOS posechain_hash. +func PoseChainHash(pc unsafe.Pointer) (uint32, error) { + _r0, _err := functions.PosechainHash(pc) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// PoseChainHashExtended is MEOS posechain_hash_extended. +func PoseChainHashExtended(pc unsafe.Pointer, seed uint64) (uint64, error) { + _r0, _err := functions.PosechainHashExtended(pc, seed) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// PoseChainRound is MEOS posechain_round. +func PoseChainRound(pc unsafe.Pointer, maxdd int) (unsafe.Pointer, error) { + _r0, _err := functions.PosechainRound(pc, maxdd) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// PoseChainSRID is MEOS posechain_srid. +func PoseChainSRID(pc unsafe.Pointer) (int32, error) { + _r0, _err := functions.PosechainSRID(pc) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// PoseChainSetSRID is MEOS posechain_set_srid. +func PoseChainSetSRID(pc unsafe.Pointer, srid int32) (unsafe.Pointer, error) { + _r0, _err := functions.PosechainSetSRID(pc, srid) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// PoseChainTransform is MEOS posechain_transform. +func PoseChainTransform(pc unsafe.Pointer, srid_to int32) (unsafe.Pointer, error) { + _r0, _err := functions.PosechainTransform(pc, srid_to) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// PoseChainTransformPipeline is MEOS posechain_transform_pipeline. +func PoseChainTransformPipeline(pc unsafe.Pointer, pipeline string, srid_to int32, is_forward bool) (unsafe.Pointer, error) { + _r0, _err := functions.PosechainTransformPipeline(pc, pipeline, srid_to, is_forward) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// PoseChainEq is MEOS posechain_eq. +func PoseChainEq(pc1 unsafe.Pointer, pc2 unsafe.Pointer) (bool, error) { + _r0, _err := functions.PosechainEq(pc1, pc2) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// PoseChainNe is MEOS posechain_ne. +func PoseChainNe(pc1 unsafe.Pointer, pc2 unsafe.Pointer) (bool, error) { + _r0, _err := functions.PosechainNe(pc1, pc2) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// PoseChainSame is MEOS posechain_same. +func PoseChainSame(pc1 unsafe.Pointer, pc2 unsafe.Pointer) (bool, error) { + _r0, _err := functions.PosechainSame(pc1, pc2) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// PoseChainNsame is MEOS posechain_nsame. +func PoseChainNsame(pc1 unsafe.Pointer, pc2 unsafe.Pointer) (bool, error) { + _r0, _err := functions.PosechainNsame(pc1, pc2) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// PoseChainCmp is MEOS posechain_cmp. +func PoseChainCmp(pc1 unsafe.Pointer, pc2 unsafe.Pointer) (int, error) { + _r0, _err := functions.PosechainCmp(pc1, pc2) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// PoseChainLt is MEOS posechain_lt. +func PoseChainLt(pc1 unsafe.Pointer, pc2 unsafe.Pointer) (bool, error) { + _r0, _err := functions.PosechainLt(pc1, pc2) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// PoseChainLe is MEOS posechain_le. +func PoseChainLe(pc1 unsafe.Pointer, pc2 unsafe.Pointer) (bool, error) { + _r0, _err := functions.PosechainLe(pc1, pc2) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// PoseChainGt is MEOS posechain_gt. +func PoseChainGt(pc1 unsafe.Pointer, pc2 unsafe.Pointer) (bool, error) { + _r0, _err := functions.PosechainGt(pc1, pc2) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// PoseChainGe is MEOS posechain_ge. +func PoseChainGe(pc1 unsafe.Pointer, pc2 unsafe.Pointer) (bool, error) { + _r0, _err := functions.PosechainGe(pc1, pc2) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// PoseChainToSet is MEOS posechain_to_set. +func PoseChainToSet(pc unsafe.Pointer) (*Set, error) { + _r0, _err := functions.PosechainToSet(pc) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} diff --git a/types/poseset.go b/types/poseset.go new file mode 100644 index 0000000..98d99a5 --- /dev/null +++ b/types/poseset.go @@ -0,0 +1,90 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type PoseSet struct { + Set +} + +// PoseSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func PoseSetFromPointer(p unsafe.Pointer) *PoseSet { + if p == nil { + return nil + } + v := &PoseSet{} + v.ptr = p + return v +} + +// PoseSetIn is MEOS poseset_in. +func PoseSetIn(str string) (*Set, error) { + _r0, _err := functions.PosesetIn(str) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS poseset_out. +func (x *PoseSet) Out(maxdd int) (string, error) { + _r0, _err := functions.PosesetOut(functions.SetFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// PoseSetMake is MEOS poseset_make. +func PoseSetMake(values unsafe.Pointer, count int) (*Set, error) { + _r0, _err := functions.PosesetMake(values, count) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS poseset_end_value. +func (x *PoseSet) EndValue() (*Pose, error) { + _r0, _err := functions.PosesetEndValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// StartValue is MEOS poseset_start_value. +func (x *PoseSet) StartValue() (*Pose, error) { + _r0, _err := functions.PosesetStartValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// ValueN is MEOS poseset_value_n. +func (x *PoseSet) ValueN(n int) (*Pose, bool, error) { + _found, _value, _err := functions.PosesetValueN(functions.SetFromPointer(x.Pointer()), n) + if _err != nil { + return nil, false, _err + } + if !_found { + return nil, false, nil + } + return PoseFromPointer(_value.Pointer()), true, nil +} + +// Values is MEOS poseset_values. +func (x *PoseSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.PosesetValues(functions.SetFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} diff --git a/types/raquet.go b/types/raquet.go new file mode 100644 index 0000000..6b3b0cb --- /dev/null +++ b/types/raquet.go @@ -0,0 +1,22 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" +) + +type Raquet struct { + Value +} + +// RaquetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func RaquetFromPointer(p unsafe.Pointer) *Raquet { + if p == nil { + return nil + } + v := &Raquet{} + v.ptr = p + return v +} diff --git a/types/rtree.go b/types/rtree.go new file mode 100644 index 0000000..6ccf015 --- /dev/null +++ b/types/rtree.go @@ -0,0 +1,164 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type RTree struct { + Value +} + +// RTreeFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func RTreeFromPointer(p unsafe.Pointer) *RTree { + if p == nil { + return nil + } + v := &RTree{} + v.ptr = p + return v +} + +// RTreeCreateIntspan is MEOS rtree_create_intspan. +func RTreeCreateIntspan() (*RTree, error) { + _r0, _err := functions.RtreeCreateIntspan() + if _err != nil { + return nil, _err + } + return RTreeFromPointer(_r0.Pointer()), nil +} + +// RTreeCreateBigintspan is MEOS rtree_create_bigintspan. +func RTreeCreateBigintspan() (*RTree, error) { + _r0, _err := functions.RtreeCreateBigintspan() + if _err != nil { + return nil, _err + } + return RTreeFromPointer(_r0.Pointer()), nil +} + +// RTreeCreateFloatspan is MEOS rtree_create_floatspan. +func RTreeCreateFloatspan() (*RTree, error) { + _r0, _err := functions.RtreeCreateFloatspan() + if _err != nil { + return nil, _err + } + return RTreeFromPointer(_r0.Pointer()), nil +} + +// RTreeCreateDatespan is MEOS rtree_create_datespan. +func RTreeCreateDatespan() (*RTree, error) { + _r0, _err := functions.RtreeCreateDatespan() + if _err != nil { + return nil, _err + } + return RTreeFromPointer(_r0.Pointer()), nil +} + +// RTreeCreateTstzspan is MEOS rtree_create_tstzspan. +func RTreeCreateTstzspan() (*RTree, error) { + _r0, _err := functions.RtreeCreateTstzspan() + if _err != nil { + return nil, _err + } + return RTreeFromPointer(_r0.Pointer()), nil +} + +// RTreeCreateTbox is MEOS rtree_create_tbox. +func RTreeCreateTbox() (*RTree, error) { + _r0, _err := functions.RtreeCreateTBOX() + if _err != nil { + return nil, _err + } + return RTreeFromPointer(_r0.Pointer()), nil +} + +// RTreeCreateStbox is MEOS rtree_create_stbox. +func RTreeCreateStbox() (*RTree, error) { + _r0, _err := functions.RtreeCreateSTBOX() + if _err != nil { + return nil, _err + } + return RTreeFromPointer(_r0.Pointer()), nil +} + +// RTreeCreateTpcbox is MEOS rtree_create_tpcbox. +func RTreeCreateTpcbox() (*RTree, error) { + _r0, _err := functions.RtreeCreateTpcbox() + if _err != nil { + return nil, _err + } + return RTreeFromPointer(_r0.Pointer()), nil +} + +// Free is MEOS rtree_free. +func (x *RTree) Free() error { + return functions.RtreeFree(functions.RTreeFromPointer(x.Pointer())) +} + +// NumEntries is MEOS rtree_num_entries. +func (x *RTree) NumEntries() (int, error) { + _r0, _err := functions.RtreeNumEntries(functions.RTreeFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// MemSize is MEOS rtree_mem_size. +func (x *RTree) MemSize() (int64, error) { + _r0, _err := functions.RtreeMemSize(functions.RTreeFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Height is MEOS rtree_height. +func (x *RTree) Height() (int, error) { + _r0, _err := functions.RtreeHeight(functions.RTreeFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Insert is MEOS rtree_insert. +func (x *RTree) Insert(box unsafe.Pointer, id int64) (bool, error) { + _r0, _err := functions.RtreeInsert(functions.RTreeFromPointer(x.Pointer()), box, id) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Load is MEOS rtree_load. +func (x *RTree) Load(boxes unsafe.Pointer, ids unsafe.Pointer, count int) (bool, error) { + _r0, _err := functions.RtreeLoad(functions.RTreeFromPointer(x.Pointer()), boxes, ids, count) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// InsertTemporal is MEOS rtree_insert_temporal. +func (x *RTree) InsertTemporal(temp *Temporal, id int64) (bool, error) { + _r0, _err := functions.RtreeInsertTemporal(functions.RTreeFromPointer(x.Pointer()), functions.TemporalFromPointer(temp.Pointer()), id) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// InsertTemporalSplit is MEOS rtree_insert_temporal_split. +func (x *RTree) InsertTemporalSplit(temp *Temporal, id int64, maxboxes int) (bool, error) { + _r0, _err := functions.RtreeInsertTemporalSplit(functions.RTreeFromPointer(x.Pointer()), functions.TemporalFromPointer(temp.Pointer()), id, maxboxes) + if _err != nil { + return false, _err + } + return _r0, nil +} diff --git a/types/rtreenncursor.go b/types/rtreenncursor.go new file mode 100644 index 0000000..92613a4 --- /dev/null +++ b/types/rtreenncursor.go @@ -0,0 +1,47 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type RTreeNNCursor struct { + Value +} + +// RTreeNNCursorFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func RTreeNNCursorFromPointer(p unsafe.Pointer) *RTreeNNCursor { + if p == nil { + return nil + } + v := &RTreeNNCursor{} + v.ptr = p + return v +} + +// RTreeNNCursorOpen is MEOS rtree_nn_cursor_open. +func RTreeNNCursorOpen(rtree *RTree, query unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.RtreeNnCursorOpen(functions.RTreeFromPointer(rtree.Pointer()), query) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// RTreeNNCursorNext is MEOS rtree_nn_cursor_next. +func RTreeNNCursorNext(cursor unsafe.Pointer, id_out unsafe.Pointer, dist_out unsafe.Pointer) (bool, error) { + _r0, _err := functions.RtreeNnCursorNext(cursor, id_out, dist_out) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// RTreeNNCursorClose is MEOS rtree_nn_cursor_close. +func RTreeNNCursorClose(cursor unsafe.Pointer) error { + return functions.RtreeNnCursorClose(cursor) +} diff --git a/types/set.go b/types/set.go new file mode 100644 index 0000000..d6d5ffb --- /dev/null +++ b/types/set.go @@ -0,0 +1,222 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type Set struct { + Collection +} + +// SetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func SetFromPointer(p unsafe.Pointer) *Set { + if p == nil { + return nil + } + v := &Set{} + v.ptr = p + return v +} + +// 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) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// 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) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// SetFromHEXWKB is MEOS set_from_hexwkb. +func SetFromHEXWKB(hexwkb string) (*Set, error) { + _r0, _err := functions.SetFromHexwkb(hexwkb) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// SetFromWKB is MEOS set_from_wkb. +func SetFromWKB(wkb unsafe.Pointer, size uint) (*Set, error) { + _r0, _err := functions.SetFromWKB(wkb, size) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Copy is MEOS set_copy. +func (x *Set) Copy() (*Set, error) { + _r0, _err := functions.SetCopy(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// ToSpan is MEOS set_to_span. +func (x *Set) ToSpan() (*Span, error) { + _r0, _err := functions.SetToSpan(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// ToSpanset is MEOS set_to_spanset. +func (x *Set) ToSpanset() (*SpanSet, error) { + _r0, _err := functions.SetToSpanset(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// Hash is MEOS set_hash. +func (x *Set) Hash() (uint32, error) { + _r0, _err := functions.SetHash(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// HashExtended is MEOS set_hash_extended. +func (x *Set) HashExtended(seed uint64) (uint64, error) { + _r0, _err := functions.SetHashExtended(functions.SetFromPointer(x.Pointer()), seed) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// NumValues is MEOS set_num_values. +func (x *Set) NumValues() (int, error) { + _r0, _err := functions.SetNumValues(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Round is MEOS set_round. +func (x *Set) Round(maxdd int) (*Set, error) { + _r0, _err := functions.SetRound(functions.SetFromPointer(x.Pointer()), maxdd) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Cmp is MEOS set_cmp. +func (x *Set) Cmp(s2 *Set) (int, error) { + _r0, _err := functions.SetCmp(functions.SetFromPointer(x.Pointer()), functions.SetFromPointer(s2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Eq is MEOS set_eq. +func (x *Set) Eq(s2 *Set) (bool, error) { + _r0, _err := functions.SetEq(functions.SetFromPointer(x.Pointer()), functions.SetFromPointer(s2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Ge is MEOS set_ge. +func (x *Set) Ge(s2 *Set) (bool, error) { + _r0, _err := functions.SetGe(functions.SetFromPointer(x.Pointer()), functions.SetFromPointer(s2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Gt is MEOS set_gt. +func (x *Set) Gt(s2 *Set) (bool, error) { + _r0, _err := functions.SetGt(functions.SetFromPointer(x.Pointer()), functions.SetFromPointer(s2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Le is MEOS set_le. +func (x *Set) Le(s2 *Set) (bool, error) { + _r0, _err := functions.SetLe(functions.SetFromPointer(x.Pointer()), functions.SetFromPointer(s2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Lt is MEOS set_lt. +func (x *Set) Lt(s2 *Set) (bool, error) { + _r0, _err := functions.SetLt(functions.SetFromPointer(x.Pointer()), functions.SetFromPointer(s2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Ne is MEOS set_ne. +func (x *Set) Ne(s2 *Set) (bool, error) { + _r0, _err := functions.SetNe(functions.SetFromPointer(x.Pointer()), functions.SetFromPointer(s2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Spans is MEOS set_spans. +func (x *Set) Spans(count unsafe.Pointer) (*Span, error) { + _r0, _err := functions.SetSpans(functions.SetFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// SplitEachNSpans is MEOS set_split_each_n_spans. +func (x *Set) SplitEachNSpans(elems_per_span int, count unsafe.Pointer) (*Span, error) { + _r0, _err := functions.SetSplitEachNSpans(functions.SetFromPointer(x.Pointer()), elems_per_span, count) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// SplitNSpans is MEOS set_split_n_spans. +func (x *Set) SplitNSpans(span_count int, count unsafe.Pointer) (*Span, error) { + _r0, _err := functions.SetSplitNSpans(functions.SetFromPointer(x.Pointer()), span_count, count) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// ToTbox is MEOS set_to_tbox. +func (x *Set) ToTbox() (*TBox, error) { + _r0, _err := functions.SetToTBOX(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TBoxFromPointer(_r0.Pointer()), nil +} diff --git a/types/span.go b/types/span.go new file mode 100644 index 0000000..d362268 --- /dev/null +++ b/types/span.go @@ -0,0 +1,186 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type Span struct { + Collection +} + +// SpanFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func SpanFromPointer(p unsafe.Pointer) *Span { + if p == nil { + return nil + } + v := &Span{} + v.ptr = p + return v +} + +// 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) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// 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) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// SpanFromHEXWKB is MEOS span_from_hexwkb. +func SpanFromHEXWKB(hexwkb string) (*Span, error) { + _r0, _err := functions.SpanFromHexwkb(hexwkb) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// SpanFromWKB is MEOS span_from_wkb. +func SpanFromWKB(wkb unsafe.Pointer, size uint) (*Span, error) { + _r0, _err := functions.SpanFromWKB(wkb, size) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Copy is MEOS span_copy. +func (x *Span) Copy() (*Span, error) { + _r0, _err := functions.SpanCopy(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// ToSpanset is MEOS span_to_spanset. +func (x *Span) ToSpanset() (*SpanSet, error) { + _r0, _err := functions.SpanToSpanset(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// Hash is MEOS span_hash. +func (x *Span) Hash() (uint32, error) { + _r0, _err := functions.SpanHash(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// HashExtended is MEOS span_hash_extended. +func (x *Span) HashExtended(seed uint64) (uint64, error) { + _r0, _err := functions.SpanHashExtended(functions.SpanFromPointer(x.Pointer()), seed) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// LowerInc is MEOS span_lower_inc. +func (x *Span) LowerInc() (bool, error) { + _r0, _err := functions.SpanLowerInc(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// UpperInc is MEOS span_upper_inc. +func (x *Span) UpperInc() (bool, error) { + _r0, _err := functions.SpanUpperInc(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Cmp is MEOS span_cmp. +func (x *Span) Cmp(s2 *Span) (int, error) { + _r0, _err := functions.SpanCmp(functions.SpanFromPointer(x.Pointer()), functions.SpanFromPointer(s2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Eq is MEOS span_eq. +func (x *Span) Eq(s2 *Span) (bool, error) { + _r0, _err := functions.SpanEq(functions.SpanFromPointer(x.Pointer()), functions.SpanFromPointer(s2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Ge is MEOS span_ge. +func (x *Span) Ge(s2 *Span) (bool, error) { + _r0, _err := functions.SpanGe(functions.SpanFromPointer(x.Pointer()), functions.SpanFromPointer(s2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Gt is MEOS span_gt. +func (x *Span) Gt(s2 *Span) (bool, error) { + _r0, _err := functions.SpanGt(functions.SpanFromPointer(x.Pointer()), functions.SpanFromPointer(s2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Le is MEOS span_le. +func (x *Span) Le(s2 *Span) (bool, error) { + _r0, _err := functions.SpanLe(functions.SpanFromPointer(x.Pointer()), functions.SpanFromPointer(s2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Lt is MEOS span_lt. +func (x *Span) Lt(s2 *Span) (bool, error) { + _r0, _err := functions.SpanLt(functions.SpanFromPointer(x.Pointer()), functions.SpanFromPointer(s2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Ne is MEOS span_ne. +func (x *Span) Ne(s2 *Span) (bool, error) { + _r0, _err := functions.SpanNe(functions.SpanFromPointer(x.Pointer()), functions.SpanFromPointer(s2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// ToTbox is MEOS span_to_tbox. +func (x *Span) ToTbox() (*TBox, error) { + _r0, _err := functions.SpanToTBOX(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TBoxFromPointer(_r0.Pointer()), nil +} diff --git a/types/spanset.go b/types/spanset.go new file mode 100644 index 0000000..86db18a --- /dev/null +++ b/types/spanset.go @@ -0,0 +1,267 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type SpanSet struct { + Collection +} + +// SpanSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func SpanSetFromPointer(p unsafe.Pointer) *SpanSet { + if p == nil { + return nil + } + v := &SpanSet{} + v.ptr = p + return v +} + +// 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) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// 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) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// SpanSetFromHEXWKB is MEOS spanset_from_hexwkb. +func SpanSetFromHEXWKB(hexwkb string) (*SpanSet, error) { + _r0, _err := functions.SpansetFromHexwkb(hexwkb) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// SpanSetFromWKB is MEOS spanset_from_wkb. +func SpanSetFromWKB(wkb unsafe.Pointer, size uint) (*SpanSet, error) { + _r0, _err := functions.SpansetFromWKB(wkb, size) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// Copy is MEOS spanset_copy. +func (x *SpanSet) Copy() (*SpanSet, error) { + _r0, _err := functions.SpansetCopy(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// SpanSetMake is MEOS spanset_make. +func SpanSetMake(spans *Span, count int) (*SpanSet, error) { + _r0, _err := functions.SpansetMake(functions.SpanFromPointer(spans.Pointer()), count) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// EndSpan is MEOS spanset_end_span. +func (x *SpanSet) EndSpan() (*Span, error) { + _r0, _err := functions.SpansetEndSpan(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Hash is MEOS spanset_hash. +func (x *SpanSet) Hash() (uint32, error) { + _r0, _err := functions.SpansetHash(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// HashExtended is MEOS spanset_hash_extended. +func (x *SpanSet) HashExtended(seed uint64) (uint64, error) { + _r0, _err := functions.SpansetHashExtended(functions.SpanSetFromPointer(x.Pointer()), seed) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// LowerInc is MEOS spanset_lower_inc. +func (x *SpanSet) LowerInc() (bool, error) { + _r0, _err := functions.SpansetLowerInc(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// NumSpans is MEOS spanset_num_spans. +func (x *SpanSet) NumSpans() (int, error) { + _r0, _err := functions.SpansetNumSpans(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Span is MEOS spanset_span. +func (x *SpanSet) Span() (*Span, error) { + _r0, _err := functions.SpansetSpan(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// SpanN is MEOS spanset_span_n. +func (x *SpanSet) SpanN(i int) (*Span, error) { + _r0, _err := functions.SpansetSpanN(functions.SpanSetFromPointer(x.Pointer()), i) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Spanarr is MEOS spanset_spanarr. +func (x *SpanSet) Spanarr(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.SpansetSpanarr(functions.SpanSetFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// StartSpan is MEOS spanset_start_span. +func (x *SpanSet) StartSpan() (*Span, error) { + _r0, _err := functions.SpansetStartSpan(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// UpperInc is MEOS spanset_upper_inc. +func (x *SpanSet) UpperInc() (bool, error) { + _r0, _err := functions.SpansetUpperInc(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Cmp is MEOS spanset_cmp. +func (x *SpanSet) Cmp(ss2 *SpanSet) (int, error) { + _r0, _err := functions.SpansetCmp(functions.SpanSetFromPointer(x.Pointer()), functions.SpanSetFromPointer(ss2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Eq is MEOS spanset_eq. +func (x *SpanSet) Eq(ss2 *SpanSet) (bool, error) { + _r0, _err := functions.SpansetEq(functions.SpanSetFromPointer(x.Pointer()), functions.SpanSetFromPointer(ss2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Ge is MEOS spanset_ge. +func (x *SpanSet) Ge(ss2 *SpanSet) (bool, error) { + _r0, _err := functions.SpansetGe(functions.SpanSetFromPointer(x.Pointer()), functions.SpanSetFromPointer(ss2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Gt is MEOS spanset_gt. +func (x *SpanSet) Gt(ss2 *SpanSet) (bool, error) { + _r0, _err := functions.SpansetGt(functions.SpanSetFromPointer(x.Pointer()), functions.SpanSetFromPointer(ss2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Le is MEOS spanset_le. +func (x *SpanSet) Le(ss2 *SpanSet) (bool, error) { + _r0, _err := functions.SpansetLe(functions.SpanSetFromPointer(x.Pointer()), functions.SpanSetFromPointer(ss2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Lt is MEOS spanset_lt. +func (x *SpanSet) Lt(ss2 *SpanSet) (bool, error) { + _r0, _err := functions.SpansetLt(functions.SpanSetFromPointer(x.Pointer()), functions.SpanSetFromPointer(ss2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Ne is MEOS spanset_ne. +func (x *SpanSet) Ne(ss2 *SpanSet) (bool, error) { + _r0, _err := functions.SpansetNe(functions.SpanSetFromPointer(x.Pointer()), functions.SpanSetFromPointer(ss2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Spans is MEOS spanset_spans. +func (x *SpanSet) Spans(count unsafe.Pointer) (*Span, error) { + _r0, _err := functions.SpansetSpans(functions.SpanSetFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// SplitEachNSpans is MEOS spanset_split_each_n_spans. +func (x *SpanSet) SplitEachNSpans(elems_per_span int, count unsafe.Pointer) (*Span, error) { + _r0, _err := functions.SpansetSplitEachNSpans(functions.SpanSetFromPointer(x.Pointer()), elems_per_span, count) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// SplitNSpans is MEOS spanset_split_n_spans. +func (x *SpanSet) SplitNSpans(span_count int, count unsafe.Pointer) (*Span, error) { + _r0, _err := functions.SpansetSplitNSpans(functions.SpanSetFromPointer(x.Pointer()), span_count, count) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// ToTbox is MEOS spanset_to_tbox. +func (x *SpanSet) ToTbox() (*TBox, error) { + _r0, _err := functions.SpansetToTBOX(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TBoxFromPointer(_r0.Pointer()), nil +} diff --git a/types/spnncursor.go b/types/spnncursor.go new file mode 100644 index 0000000..6175860 --- /dev/null +++ b/types/spnncursor.go @@ -0,0 +1,47 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type SPNNCursor struct { + Value +} + +// SPNNCursorFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func SPNNCursorFromPointer(p unsafe.Pointer) *SPNNCursor { + if p == nil { + return nil + } + v := &SPNNCursor{} + v.ptr = p + return v +} + +// SPNNCursorOpen is MEOS sptree_nn_cursor_open. +func SPNNCursorOpen(sptree unsafe.Pointer, query unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.SptreeNnCursorOpen(sptree, query) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// SPNNCursorNext is MEOS sptree_nn_cursor_next. +func SPNNCursorNext(cursor unsafe.Pointer, id_out unsafe.Pointer, dist_out unsafe.Pointer) (bool, error) { + _r0, _err := functions.SptreeNnCursorNext(cursor, id_out, dist_out) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// SPNNCursorClose is MEOS sptree_nn_cursor_close. +func SPNNCursorClose(cursor unsafe.Pointer) error { + return functions.SptreeNnCursorClose(cursor) +} diff --git a/types/sptree.go b/types/sptree.go new file mode 100644 index 0000000..a31e45a --- /dev/null +++ b/types/sptree.go @@ -0,0 +1,92 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type SPTree struct { + Value +} + +// SPTreeFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func SPTreeFromPointer(p unsafe.Pointer) *SPTree { + if p == nil { + return nil + } + v := &SPTree{} + v.ptr = p + return v +} + +// SPTreeFree is MEOS sptree_free. +func SPTreeFree(sptree unsafe.Pointer) error { + return functions.SptreeFree(sptree) +} + +// SPTreeNumEntries is MEOS sptree_num_entries. +func SPTreeNumEntries(sptree unsafe.Pointer) (int, error) { + _r0, _err := functions.SptreeNumEntries(sptree) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// SPTreeMemSize is MEOS sptree_mem_size. +func SPTreeMemSize(sptree unsafe.Pointer) (int64, error) { + _r0, _err := functions.SptreeMemSize(sptree) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// SPTreeHeight is MEOS sptree_height. +func SPTreeHeight(sptree unsafe.Pointer) (int, error) { + _r0, _err := functions.SptreeHeight(sptree) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// SPTreeInsert is MEOS sptree_insert. +func SPTreeInsert(sptree unsafe.Pointer, box unsafe.Pointer, id int64) (bool, error) { + _r0, _err := functions.SptreeInsert(sptree, box, id) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// SPTreeLoad is MEOS sptree_load. +func SPTreeLoad(sptree unsafe.Pointer, boxes unsafe.Pointer, ids unsafe.Pointer, count int) (bool, error) { + _r0, _err := functions.SptreeLoad(sptree, boxes, ids, count) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// SPTreeInsertTemporal is MEOS sptree_insert_temporal. +func SPTreeInsertTemporal(sptree unsafe.Pointer, temp *Temporal, id int64) (bool, error) { + _r0, _err := functions.SptreeInsertTemporal(sptree, functions.TemporalFromPointer(temp.Pointer()), id) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// SPTreeInsertTemporalSplit is MEOS sptree_insert_temporal_split. +func SPTreeInsertTemporalSplit(sptree unsafe.Pointer, temp *Temporal, id int64, maxboxes int) (bool, error) { + _r0, _err := functions.SptreeInsertTemporalSplit(sptree, functions.TemporalFromPointer(temp.Pointer()), id, maxboxes) + if _err != nil { + return false, _err + } + return _r0, nil +} diff --git a/types/stbox.go b/types/stbox.go new file mode 100644 index 0000000..59ef53b --- /dev/null +++ b/types/stbox.go @@ -0,0 +1,477 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type STBox struct { + Box +} + +// STBoxFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func STBoxFromPointer(p unsafe.Pointer) *STBox { + if p == nil { + return nil + } + v := &STBox{} + v.ptr = p + return v +} + +// 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) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// 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) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// STBoxFromHEXWKB is MEOS stbox_from_hexwkb. +func STBoxFromHEXWKB(hexwkb string) (*STBox, error) { + _r0, _err := functions.STBOXFromHexwkb(hexwkb) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// STBoxFromWKB is MEOS stbox_from_wkb. +func STBoxFromWKB(wkb unsafe.Pointer, size uint) (*STBox, error) { + _r0, _err := functions.STBOXFromWKB(wkb, size) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// STBoxIn is MEOS stbox_in. +func STBoxIn(str string) (*STBox, error) { + _r0, _err := functions.STBOXIn(str) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS stbox_out. +func (x *STBox) Out(maxdd int) (string, error) { + _r0, _err := functions.STBOXOut(functions.STBoxFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// Copy is MEOS stbox_copy. +func (x *STBox) Copy() (*STBox, error) { + _r0, _err := functions.STBOXCopy(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// STBoxMake is MEOS stbox_make. +func STBoxMake(hasx bool, hasz bool, geodetic bool, srid int32, xmin float64, xmax float64, ymin float64, ymax float64, zmin float64, zmax float64, s *Span) (*STBox, error) { + _r0, _err := functions.STBOXMake(hasx, hasz, geodetic, srid, xmin, xmax, ymin, ymax, zmin, zmax, functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// ToGeo is MEOS stbox_to_geo. +func (x *STBox) ToGeo() (*TRGeometrySeqSet, error) { + _r0, _err := functions.STBOXToGeo(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// ToTstzspan is MEOS stbox_to_tstzspan. +func (x *STBox) ToTstzspan() (*Span, error) { + _r0, _err := functions.STBOXToTstzspan(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Area is MEOS stbox_area. +func (x *STBox) Area(spheroid bool) (float64, error) { + _r0, _err := functions.STBOXArea(functions.STBoxFromPointer(x.Pointer()), spheroid) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Hash is MEOS stbox_hash. +func (x *STBox) Hash() (uint32, error) { + _r0, _err := functions.STBOXHash(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// HashExtended is MEOS stbox_hash_extended. +func (x *STBox) HashExtended(seed uint64) (uint64, error) { + _r0, _err := functions.STBOXHashExtended(functions.STBoxFromPointer(x.Pointer()), seed) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Hast is MEOS stbox_hast. +func (x *STBox) Hast() (bool, error) { + _r0, _err := functions.STBOXHast(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Hasx is MEOS stbox_hasx. +func (x *STBox) Hasx() (bool, error) { + _r0, _err := functions.STBOXHasx(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Hasz is MEOS stbox_hasz. +func (x *STBox) Hasz() (bool, error) { + _r0, _err := functions.STBOXHasz(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Isgeodetic is MEOS stbox_isgeodetic. +func (x *STBox) Isgeodetic() (bool, error) { + _r0, _err := functions.STBOXIsgeodetic(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Perimeter is MEOS stbox_perimeter. +func (x *STBox) Perimeter(spheroid bool) (float64, error) { + _r0, _err := functions.STBOXPerimeter(functions.STBoxFromPointer(x.Pointer()), spheroid) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Tmax is MEOS stbox_tmax. +func (x *STBox) Tmax() (int64, bool, error) { + _found, _value, _err := functions.STBOXTmax(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// TmaxInc is MEOS stbox_tmax_inc. +func (x *STBox) TmaxInc() (bool, bool, error) { + _found, _value, _err := functions.STBOXTmaxInc(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return false, false, _err + } + if !_found { + return false, false, nil + } + return _value, true, nil +} + +// Tmin is MEOS stbox_tmin. +func (x *STBox) Tmin() (int64, bool, error) { + _found, _value, _err := functions.STBOXTmin(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// TminInc is MEOS stbox_tmin_inc. +func (x *STBox) TminInc() (bool, bool, error) { + _found, _value, _err := functions.STBOXTminInc(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return false, false, _err + } + if !_found { + return false, false, nil + } + return _value, true, nil +} + +// Volume is MEOS stbox_volume. +func (x *STBox) Volume() (float64, error) { + _r0, _err := functions.STBOXVolume(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Xmax is MEOS stbox_xmax. +func (x *STBox) Xmax() (float64, bool, error) { + _found, _value, _err := functions.STBOXXmax(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// Xmin is MEOS stbox_xmin. +func (x *STBox) Xmin() (float64, bool, error) { + _found, _value, _err := functions.STBOXXmin(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// Ymax is MEOS stbox_ymax. +func (x *STBox) Ymax() (float64, bool, error) { + _found, _value, _err := functions.STBOXYmax(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// Ymin is MEOS stbox_ymin. +func (x *STBox) Ymin() (float64, bool, error) { + _found, _value, _err := functions.STBOXYmin(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// Zmax is MEOS stbox_zmax. +func (x *STBox) Zmax() (float64, bool, error) { + _found, _value, _err := functions.STBOXZmax(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// Zmin is MEOS stbox_zmin. +func (x *STBox) Zmin() (float64, bool, error) { + _found, _value, _err := functions.STBOXZmin(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// ExpandSpace is MEOS stbox_expand_space. +func (x *STBox) ExpandSpace(d float64) (*STBox, error) { + _r0, _err := functions.STBOXExpandSpace(functions.STBoxFromPointer(x.Pointer()), d) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// GetSpace is MEOS stbox_get_space. +func (x *STBox) GetSpace() (*STBox, error) { + _r0, _err := functions.STBOXGetSpace(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// QuadSplit is MEOS stbox_quad_split. +func (x *STBox) QuadSplit(count unsafe.Pointer) (*STBox, error) { + _r0, _err := functions.STBOXQuadSplit(functions.STBoxFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// Round is MEOS stbox_round. +func (x *STBox) Round(maxdd int) (*STBox, error) { + _r0, _err := functions.STBOXRound(functions.STBoxFromPointer(x.Pointer()), maxdd) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// SetSRID is MEOS stbox_set_srid. +func (x *STBox) SetSRID(srid int32) (*STBox, error) { + _r0, _err := functions.STBOXSetSRID(functions.STBoxFromPointer(x.Pointer()), srid) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// SRID is MEOS stbox_srid. +func (x *STBox) SRID() (int32, error) { + _r0, _err := functions.STBOXSRID(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Transform is MEOS stbox_transform. +func (x *STBox) Transform(srid int32) (*STBox, error) { + _r0, _err := functions.STBOXTransform(functions.STBoxFromPointer(x.Pointer()), srid) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// TransformPipeline is MEOS stbox_transform_pipeline. +func (x *STBox) TransformPipeline(pipelinestr string, srid int32, is_forward bool) (*STBox, error) { + _r0, _err := functions.STBOXTransformPipeline(functions.STBoxFromPointer(x.Pointer()), pipelinestr, srid, is_forward) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// Cmp is MEOS stbox_cmp. +func (x *STBox) Cmp(box2 *STBox) (int, error) { + _r0, _err := functions.STBOXCmp(functions.STBoxFromPointer(x.Pointer()), functions.STBoxFromPointer(box2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Eq is MEOS stbox_eq. +func (x *STBox) Eq(box2 *STBox) (bool, error) { + _r0, _err := functions.STBOXEq(functions.STBoxFromPointer(x.Pointer()), functions.STBoxFromPointer(box2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Ge is MEOS stbox_ge. +func (x *STBox) Ge(box2 *STBox) (bool, error) { + _r0, _err := functions.STBOXGe(functions.STBoxFromPointer(x.Pointer()), functions.STBoxFromPointer(box2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Gt is MEOS stbox_gt. +func (x *STBox) Gt(box2 *STBox) (bool, error) { + _r0, _err := functions.STBOXGt(functions.STBoxFromPointer(x.Pointer()), functions.STBoxFromPointer(box2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Le is MEOS stbox_le. +func (x *STBox) Le(box2 *STBox) (bool, error) { + _r0, _err := functions.STBOXLe(functions.STBoxFromPointer(x.Pointer()), functions.STBoxFromPointer(box2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Lt is MEOS stbox_lt. +func (x *STBox) Lt(box2 *STBox) (bool, error) { + _r0, _err := functions.STBOXLt(functions.STBoxFromPointer(x.Pointer()), functions.STBoxFromPointer(box2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Ne is MEOS stbox_ne. +func (x *STBox) Ne(box2 *STBox) (bool, error) { + _r0, _err := functions.STBOXNe(functions.STBoxFromPointer(x.Pointer()), functions.STBoxFromPointer(box2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// SpatialDistance is MEOS stbox_spatial_distance. +func (x *STBox) SpatialDistance(box2 *STBox) (float64, error) { + _r0, _err := functions.STBOXSpatialDistance(functions.STBoxFromPointer(x.Pointer()), functions.STBoxFromPointer(box2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// STBoxGetSpaceTile is MEOS stbox_get_space_tile. +func STBoxGetSpaceTile(point *TRGeometrySeqSet, xsize float64, ysize float64, zsize float64, sorigin *TRGeometrySeqSet) (*STBox, error) { + _r0, _err := functions.STBOXGetSpaceTile(functions.GeomFromPointer(point.Pointer()), xsize, ysize, zsize, functions.GeomFromPointer(sorigin.Pointer())) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// SpaceTiles is MEOS stbox_space_tiles. +func (x *STBox) SpaceTiles(xsize float64, ysize float64, zsize float64, sorigin *TRGeometrySeqSet, border_inc bool, count unsafe.Pointer) (*STBox, error) { + _r0, _err := functions.STBOXSpaceTiles(functions.STBoxFromPointer(x.Pointer()), xsize, ysize, zsize, functions.GeomFromPointer(sorigin.Pointer()), border_inc, count) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} diff --git a/types/talpha.go b/types/talpha.go new file mode 100644 index 0000000..96db81c --- /dev/null +++ b/types/talpha.go @@ -0,0 +1,24 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" +) + +// TAlpha is non-numeric, non-spatial temporal types (step/discrete interpolation only). A real MEOS grouping (talpha_type) with no user-facing class name in PyMEOS — see corrections. + +type TAlpha struct { + Temporal +} + +// TAlphaFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TAlphaFromPointer(p unsafe.Pointer) *TAlpha { + if p == nil { + return nil + } + v := &TAlpha{} + v.ptr = p + return v +} diff --git a/types/tbigint.go b/types/tbigint.go new file mode 100644 index 0000000..f49e9c7 --- /dev/null +++ b/types/tbigint.go @@ -0,0 +1,192 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TBigint struct { + TNumber +} + +// TBigintFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TBigintFromPointer(p unsafe.Pointer) *TBigint { + if p == nil { + return nil + } + v := &TBigint{} + v.ptr = p + return v +} + +// TBigintFromMFJSON is MEOS tbigint_from_mfjson. +func TBigintFromMFJSON(str string) (*Temporal, error) { + _r0, _err := functions.TbigintFromMFJSON(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TBigintIn is MEOS tbigint_in. +func TBigintIn(str string) (*Temporal, error) { + _r0, _err := functions.TbigintIn(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS tbigint_out. +func (x *TBigint) Out() (string, error) { + _r0, _err := functions.TbigintOut(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// TBigintFromBaseTemp is MEOS tbigint_from_base_temp. +func TBigintFromBaseTemp(i int64, temp *Temporal) (*Temporal, error) { + _r0, _err := functions.TbigintFromBaseTemp(i, functions.TemporalFromPointer(temp.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTint is MEOS tbigint_to_tint. +func (x *TBigint) ToTint() (*Temporal, error) { + _r0, _err := functions.TbigintToTint(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTfloat is MEOS tbigint_to_tfloat. +func (x *TBigint) ToTfloat() (*Temporal, error) { + _r0, _err := functions.TbigintToTfloat(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS tbigint_end_value. +func (x *TBigint) EndValue() (int64, error) { + _r0, _err := functions.TbigintEndValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// MaxValue is MEOS tbigint_max_value. +func (x *TBigint) MaxValue() (int64, error) { + _r0, _err := functions.TbigintMaxValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// MinValue is MEOS tbigint_min_value. +func (x *TBigint) MinValue() (int64, error) { + _r0, _err := functions.TbigintMinValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// StartValue is MEOS tbigint_start_value. +func (x *TBigint) StartValue() (int64, error) { + _r0, _err := functions.TbigintStartValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ValueAtTimestamptz is MEOS tbigint_value_at_timestamptz. +func (x *TBigint) ValueAtTimestamptz(t int64, strict bool) (int64, bool, error) { + _found, _value, _err := functions.TbigintValueAtTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, strict) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// ValueN is MEOS tbigint_value_n. +func (x *TBigint) ValueN(n int64) (int64, bool, error) { + _found, _value, _err := functions.TbigintValueN(functions.TemporalFromPointer(x.Pointer()), n) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// Values is MEOS tbigint_values. +func (x *TBigint) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TbigintValues(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// ScaleValue is MEOS tbigint_scale_value. +func (x *TBigint) ScaleValue(width int64) (*Temporal, error) { + _r0, _err := functions.TbigintScaleValue(functions.TemporalFromPointer(x.Pointer()), width) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ShiftScaleValue is MEOS tbigint_shift_scale_value. +func (x *TBigint) ShiftScaleValue(shift int64, width int64) (*Temporal, error) { + _r0, _err := functions.TbigintShiftScaleValue(functions.TemporalFromPointer(x.Pointer()), shift, width) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ShiftValue is MEOS tbigint_shift_value. +func (x *TBigint) ShiftValue(shift int64) (*Temporal, error) { + _r0, _err := functions.TbigintShiftValue(functions.TemporalFromPointer(x.Pointer()), shift) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTh3index is MEOS tbigint_to_th3index. +func (x *TBigint) ToTh3index() (*Temporal, error) { + _r0, _err := functions.TbigintToTh3index(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTquadbin is MEOS tbigint_to_tquadbin. +func (x *TBigint) ToTquadbin() (*Temporal, error) { + _r0, _err := functions.TbigintToTquadbin(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tbigintinst.go b/types/tbigintinst.go new file mode 100644 index 0000000..45cfe60 --- /dev/null +++ b/types/tbigintinst.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TBigintInst struct { + handle +} + +// TBigintInstFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TBigintInstFromPointer(p unsafe.Pointer) *TBigintInst { + if p == nil { + return nil + } + v := &TBigintInst{} + v.ptr = p + return v +} + +// TBigintInstMake is MEOS tbigintinst_make. +func TBigintInstMake(i int64, t int64) (*Temporal, error) { + _r0, _err := functions.TbigintinstMake(i, t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tbigintseq.go b/types/tbigintseq.go new file mode 100644 index 0000000..f0becf8 --- /dev/null +++ b/types/tbigintseq.go @@ -0,0 +1,42 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TBigintSeq struct { + handle +} + +// TBigintSeqFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TBigintSeqFromPointer(p unsafe.Pointer) *TBigintSeq { + if p == nil { + return nil + } + v := &TBigintSeq{} + v.ptr = p + return v +} + +// TBigintSeqFromBaseTstzset is MEOS tbigintseq_from_base_tstzset. +func TBigintSeqFromBaseTstzset(i int64, s *Set) (*Temporal, error) { + _r0, _err := functions.TbigintseqFromBaseTstzset(i, functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TBigintSeqFromBaseTstzspan is MEOS tbigintseq_from_base_tstzspan. +func TBigintSeqFromBaseTstzspan(i int64, s *Span) (*Temporal, error) { + _r0, _err := functions.TbigintseqFromBaseTstzspan(i, functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tbigintseqset.go b/types/tbigintseqset.go new file mode 100644 index 0000000..8114759 --- /dev/null +++ b/types/tbigintseqset.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TBigintSeqSet struct { + handle +} + +// TBigintSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TBigintSeqSetFromPointer(p unsafe.Pointer) *TBigintSeqSet { + if p == nil { + return nil + } + v := &TBigintSeqSet{} + v.ptr = p + return v +} + +// TBigintSeqSetFromBaseTstzspanset is MEOS tbigintseqset_from_base_tstzspanset. +func TBigintSeqSetFromBaseTstzspanset(i int64, ss *SpanSet) (*Temporal, error) { + _r0, _err := functions.TbigintseqsetFromBaseTstzspanset(i, functions.SpanSetFromPointer(ss.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tbool.go b/types/tbool.go new file mode 100644 index 0000000..74ea38a --- /dev/null +++ b/types/tbool.go @@ -0,0 +1,147 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TBool struct { + TAlpha +} + +// TBoolFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TBoolFromPointer(p unsafe.Pointer) *TBool { + if p == nil { + return nil + } + v := &TBool{} + v.ptr = p + return v +} + +// TBoolFromMFJSON is MEOS tbool_from_mfjson. +func TBoolFromMFJSON(str string) (*Temporal, error) { + _r0, _err := functions.TboolFromMFJSON(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TBoolIn is MEOS tbool_in. +func TBoolIn(str string) (*Temporal, error) { + _r0, _err := functions.TboolIn(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS tbool_out. +func (x *TBool) Out() (string, error) { + _r0, _err := functions.TboolOut(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// TBoolFromBaseTemp is MEOS tbool_from_base_temp. +func TBoolFromBaseTemp(b bool, temp *Temporal) (*Temporal, error) { + _r0, _err := functions.TboolFromBaseTemp(b, functions.TemporalFromPointer(temp.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTint is MEOS tbool_to_tint. +func (x *TBool) ToTint() (*Temporal, error) { + _r0, _err := functions.TboolToTint(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS tbool_end_value. +func (x *TBool) EndValue() (bool, error) { + _r0, _err := functions.TboolEndValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// StartValue is MEOS tbool_start_value. +func (x *TBool) StartValue() (bool, error) { + _r0, _err := functions.TboolStartValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// ValueAtTimestamptz is MEOS tbool_value_at_timestamptz. +func (x *TBool) ValueAtTimestamptz(t int64, strict bool) (bool, bool, error) { + _found, _value, _err := functions.TboolValueAtTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, strict) + if _err != nil { + return false, false, _err + } + if !_found { + return false, false, nil + } + return _value, true, nil +} + +// ValueN is MEOS tbool_value_n. +func (x *TBool) ValueN(n int) (bool, bool, error) { + _found, _value, _err := functions.TboolValueN(functions.TemporalFromPointer(x.Pointer()), n) + if _err != nil { + return false, false, _err + } + if !_found { + return false, false, nil + } + return _value, true, nil +} + +// Values is MEOS tbool_values. +func (x *TBool) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TboolValues(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// AtValue is MEOS tbool_at_value. +func (x *TBool) AtValue(b bool) (*Temporal, error) { + _r0, _err := functions.TboolAtValue(functions.TemporalFromPointer(x.Pointer()), b) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusValue is MEOS tbool_minus_value. +func (x *TBool) MinusValue(b bool) (*Temporal, error) { + _r0, _err := functions.TboolMinusValue(functions.TemporalFromPointer(x.Pointer()), b) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// WhenTrue is MEOS tbool_when_true. +func (x *TBool) WhenTrue() (*SpanSet, error) { + _r0, _err := functions.TboolWhenTrue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} diff --git a/types/tboolinst.go b/types/tboolinst.go new file mode 100644 index 0000000..7283456 --- /dev/null +++ b/types/tboolinst.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TBoolInst struct { + handle +} + +// TBoolInstFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TBoolInstFromPointer(p unsafe.Pointer) *TBoolInst { + if p == nil { + return nil + } + v := &TBoolInst{} + v.ptr = p + return v +} + +// TBoolInstMake is MEOS tboolinst_make. +func TBoolInstMake(b bool, t int64) (*Temporal, error) { + _r0, _err := functions.TboolinstMake(b, t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tboolseq.go b/types/tboolseq.go new file mode 100644 index 0000000..04812dc --- /dev/null +++ b/types/tboolseq.go @@ -0,0 +1,42 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TBoolSeq struct { + handle +} + +// TBoolSeqFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TBoolSeqFromPointer(p unsafe.Pointer) *TBoolSeq { + if p == nil { + return nil + } + v := &TBoolSeq{} + v.ptr = p + return v +} + +// TBoolSeqFromBaseTstzset is MEOS tboolseq_from_base_tstzset. +func TBoolSeqFromBaseTstzset(b bool, s *Set) (*Temporal, error) { + _r0, _err := functions.TboolseqFromBaseTstzset(b, functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TBoolSeqFromBaseTstzspan is MEOS tboolseq_from_base_tstzspan. +func TBoolSeqFromBaseTstzspan(b bool, s *Span) (*Temporal, error) { + _r0, _err := functions.TboolseqFromBaseTstzspan(b, functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tboolseqset.go b/types/tboolseqset.go new file mode 100644 index 0000000..d20e57f --- /dev/null +++ b/types/tboolseqset.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TBoolSeqSet struct { + handle +} + +// TBoolSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TBoolSeqSetFromPointer(p unsafe.Pointer) *TBoolSeqSet { + if p == nil { + return nil + } + v := &TBoolSeqSet{} + v.ptr = p + return v +} + +// TBoolSeqSetFromBaseTstzspanset is MEOS tboolseqset_from_base_tstzspanset. +func TBoolSeqSetFromBaseTstzspanset(b bool, ss *SpanSet) (*Temporal, error) { + _r0, _err := functions.TboolseqsetFromBaseTstzspanset(b, functions.SpanSetFromPointer(ss.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tbox.go b/types/tbox.go new file mode 100644 index 0000000..ea24554 --- /dev/null +++ b/types/tbox.go @@ -0,0 +1,336 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TBox struct { + Box +} + +// TBoxFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TBoxFromPointer(p unsafe.Pointer) *TBox { + if p == nil { + return nil + } + v := &TBox{} + v.ptr = p + return v +} + +// 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) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// 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) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// TBoxFromHEXWKB is MEOS tbox_from_hexwkb. +func TBoxFromHEXWKB(hexwkb string) (*TBox, error) { + _r0, _err := functions.TBOXFromHexwkb(hexwkb) + if _err != nil { + return nil, _err + } + return TBoxFromPointer(_r0.Pointer()), nil +} + +// TBoxFromWKB is MEOS tbox_from_wkb. +func TBoxFromWKB(wkb unsafe.Pointer, size uint) (*TBox, error) { + _r0, _err := functions.TBOXFromWKB(wkb, size) + if _err != nil { + return nil, _err + } + return TBoxFromPointer(_r0.Pointer()), nil +} + +// TBoxIn is MEOS tbox_in. +func TBoxIn(str string) (*TBox, error) { + _r0, _err := functions.TBOXIn(str) + if _err != nil { + return nil, _err + } + return TBoxFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS tbox_out. +func (x *TBox) Out(maxdd int) (string, error) { + _r0, _err := functions.TBOXOut(functions.TBoxFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// Copy is MEOS tbox_copy. +func (x *TBox) Copy() (*TBox, error) { + _r0, _err := functions.TBOXCopy(functions.TBoxFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TBoxFromPointer(_r0.Pointer()), nil +} + +// TBoxMake is MEOS tbox_make. +func TBoxMake(s *Span, p *Span) (*TBox, error) { + _r0, _err := functions.TBOXMake(functions.SpanFromPointer(s.Pointer()), functions.SpanFromPointer(p.Pointer())) + if _err != nil { + return nil, _err + } + return TBoxFromPointer(_r0.Pointer()), nil +} + +// ToIntspan is MEOS tbox_to_intspan. +func (x *TBox) ToIntspan() (*Span, error) { + _r0, _err := functions.TBOXToIntspan(functions.TBoxFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// ToBigintspan is MEOS tbox_to_bigintspan. +func (x *TBox) ToBigintspan() (*Span, error) { + _r0, _err := functions.TBOXToBigintspan(functions.TBoxFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// ToFloatspan is MEOS tbox_to_floatspan. +func (x *TBox) ToFloatspan() (*Span, error) { + _r0, _err := functions.TBOXToFloatspan(functions.TBoxFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// ToTstzspan is MEOS tbox_to_tstzspan. +func (x *TBox) ToTstzspan() (*Span, error) { + _r0, _err := functions.TBOXToTstzspan(functions.TBoxFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Hash is MEOS tbox_hash. +func (x *TBox) Hash() (uint32, error) { + _r0, _err := functions.TBOXHash(functions.TBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// HashExtended is MEOS tbox_hash_extended. +func (x *TBox) HashExtended(seed uint64) (uint64, error) { + _r0, _err := functions.TBOXHashExtended(functions.TBoxFromPointer(x.Pointer()), seed) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Hast is MEOS tbox_hast. +func (x *TBox) Hast() (bool, error) { + _r0, _err := functions.TBOXHast(functions.TBoxFromPointer(x.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Hasx is MEOS tbox_hasx. +func (x *TBox) Hasx() (bool, error) { + _r0, _err := functions.TBOXHasx(functions.TBoxFromPointer(x.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Tmax is MEOS tbox_tmax. +func (x *TBox) Tmax() (int64, bool, error) { + _found, _value, _err := functions.TBOXTmax(functions.TBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// TmaxInc is MEOS tbox_tmax_inc. +func (x *TBox) TmaxInc() (bool, bool, error) { + _found, _value, _err := functions.TBOXTmaxInc(functions.TBoxFromPointer(x.Pointer())) + if _err != nil { + return false, false, _err + } + if !_found { + return false, false, nil + } + return _value, true, nil +} + +// Tmin is MEOS tbox_tmin. +func (x *TBox) Tmin() (int64, bool, error) { + _found, _value, _err := functions.TBOXTmin(functions.TBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// TminInc is MEOS tbox_tmin_inc. +func (x *TBox) TminInc() (bool, bool, error) { + _found, _value, _err := functions.TBOXTminInc(functions.TBoxFromPointer(x.Pointer())) + if _err != nil { + return false, false, _err + } + if !_found { + return false, false, nil + } + return _value, true, nil +} + +// Xmax is MEOS tbox_xmax. +func (x *TBox) Xmax() (float64, bool, error) { + _found, _value, _err := functions.TBOXXmax(functions.TBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// XmaxInc is MEOS tbox_xmax_inc. +func (x *TBox) XmaxInc() (bool, bool, error) { + _found, _value, _err := functions.TBOXXmaxInc(functions.TBoxFromPointer(x.Pointer())) + if _err != nil { + return false, false, _err + } + if !_found { + return false, false, nil + } + return _value, true, nil +} + +// Xmin is MEOS tbox_xmin. +func (x *TBox) Xmin() (float64, bool, error) { + _found, _value, _err := functions.TBOXXmin(functions.TBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// XminInc is MEOS tbox_xmin_inc. +func (x *TBox) XminInc() (bool, bool, error) { + _found, _value, _err := functions.TBOXXminInc(functions.TBoxFromPointer(x.Pointer())) + if _err != nil { + return false, false, _err + } + if !_found { + return false, false, nil + } + return _value, true, nil +} + +// Round is MEOS tbox_round. +func (x *TBox) Round(maxdd int) (*TBox, error) { + _r0, _err := functions.TBOXRound(functions.TBoxFromPointer(x.Pointer()), maxdd) + if _err != nil { + return nil, _err + } + return TBoxFromPointer(_r0.Pointer()), nil +} + +// Cmp is MEOS tbox_cmp. +func (x *TBox) Cmp(box2 *TBox) (int, error) { + _r0, _err := functions.TBOXCmp(functions.TBoxFromPointer(x.Pointer()), functions.TBoxFromPointer(box2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Eq is MEOS tbox_eq. +func (x *TBox) Eq(box2 *TBox) (bool, error) { + _r0, _err := functions.TBOXEq(functions.TBoxFromPointer(x.Pointer()), functions.TBoxFromPointer(box2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Ge is MEOS tbox_ge. +func (x *TBox) Ge(box2 *TBox) (bool, error) { + _r0, _err := functions.TBOXGe(functions.TBoxFromPointer(x.Pointer()), functions.TBoxFromPointer(box2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Gt is MEOS tbox_gt. +func (x *TBox) Gt(box2 *TBox) (bool, error) { + _r0, _err := functions.TBOXGt(functions.TBoxFromPointer(x.Pointer()), functions.TBoxFromPointer(box2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Le is MEOS tbox_le. +func (x *TBox) Le(box2 *TBox) (bool, error) { + _r0, _err := functions.TBOXLe(functions.TBoxFromPointer(x.Pointer()), functions.TBoxFromPointer(box2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Lt is MEOS tbox_lt. +func (x *TBox) Lt(box2 *TBox) (bool, error) { + _r0, _err := functions.TBOXLt(functions.TBoxFromPointer(x.Pointer()), functions.TBoxFromPointer(box2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Ne is MEOS tbox_ne. +func (x *TBox) Ne(box2 *TBox) (bool, error) { + _r0, _err := functions.TBOXNe(functions.TBoxFromPointer(x.Pointer()), functions.TBoxFromPointer(box2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} diff --git a/types/tcbuffer.go b/types/tcbuffer.go new file mode 100644 index 0000000..d211e97 --- /dev/null +++ b/types/tcbuffer.go @@ -0,0 +1,228 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TCbuffer struct { + TSpatial +} + +// TCbufferFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TCbufferFromPointer(p unsafe.Pointer) *TCbuffer { + if p == nil { + return nil + } + v := &TCbuffer{} + v.ptr = p + return v +} + +// TCbufferIn is MEOS tcbuffer_in. +func TCbufferIn(str string) (*Temporal, error) { + _r0, _err := functions.TcbufferIn(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TCbufferFromMFJSON is MEOS tcbuffer_from_mfjson. +func TCbufferFromMFJSON(mfjson string) (*Temporal, error) { + _r0, _err := functions.TcbufferFromMFJSON(mfjson) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Make is MEOS tcbuffer_make. +func (x *TCbuffer) Make(tfloat *Temporal) (*Temporal, error) { + _r0, _err := functions.TcbufferMake(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(tfloat.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TCbufferFromBaseTemp is MEOS tcbuffer_from_base_temp. +func TCbufferFromBaseTemp(cb *Cbuffer, temp *Temporal) (*Temporal, error) { + _r0, _err := functions.TcbufferFromBaseTemp(functions.CbufferFromPointer(cb.Pointer()), functions.TemporalFromPointer(temp.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS tcbuffer_end_value. +func (x *TCbuffer) EndValue() (*Cbuffer, error) { + _r0, _err := functions.TcbufferEndValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return CbufferFromPointer(_r0.Pointer()), nil +} + +// Points is MEOS tcbuffer_points. +func (x *TCbuffer) Points() (*Set, error) { + _r0, _err := functions.TcbufferPoints(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Radius is MEOS tcbuffer_radius. +func (x *TCbuffer) Radius() (*Set, error) { + _r0, _err := functions.TcbufferRadius(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// TraversedArea is MEOS tcbuffer_traversed_area. +func (x *TCbuffer) TraversedArea(unary_union bool) (*TRGeometrySeqSet, error) { + _r0, _err := functions.TcbufferTraversedArea(functions.TemporalFromPointer(x.Pointer()), unary_union) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// ConvexHull is MEOS tcbuffer_convex_hull. +func (x *TCbuffer) ConvexHull() (*TRGeometrySeqSet, error) { + _r0, _err := functions.TcbufferConvexHull(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// StartValue is MEOS tcbuffer_start_value. +func (x *TCbuffer) StartValue() (*Cbuffer, error) { + _r0, _err := functions.TcbufferStartValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return CbufferFromPointer(_r0.Pointer()), nil +} + +// ValueAtTimestamptz is MEOS tcbuffer_value_at_timestamptz. +func (x *TCbuffer) ValueAtTimestamptz(t int64, strict bool) (*Cbuffer, bool, error) { + _found, _value, _err := functions.TcbufferValueAtTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, strict) + if _err != nil { + return nil, false, _err + } + if !_found { + return nil, false, nil + } + return CbufferFromPointer(_value.Pointer()), true, nil +} + +// ValueN is MEOS tcbuffer_value_n. +func (x *TCbuffer) ValueN(n int) (*Cbuffer, bool, error) { + _found, _value, _err := functions.TcbufferValueN(functions.TemporalFromPointer(x.Pointer()), n) + if _err != nil { + return nil, false, _err + } + if !_found { + return nil, false, nil + } + return CbufferFromPointer(_value.Pointer()), true, nil +} + +// Values is MEOS tcbuffer_values. +func (x *TCbuffer) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TcbufferValues(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// ToTfloat is MEOS tcbuffer_to_tfloat. +func (x *TCbuffer) ToTfloat() (*Temporal, error) { + _r0, _err := functions.TcbufferToTfloat(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTgeompoint is MEOS tcbuffer_to_tgeompoint. +func (x *TCbuffer) ToTgeompoint() (*Temporal, error) { + _r0, _err := functions.TcbufferToTgeompoint(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Expand is MEOS tcbuffer_expand. +func (x *TCbuffer) Expand(dist float64) (*Temporal, error) { + _r0, _err := functions.TcbufferExpand(functions.TemporalFromPointer(x.Pointer()), dist) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtCbuffer is MEOS tcbuffer_at_cbuffer. +func (x *TCbuffer) AtCbuffer(cb *Cbuffer) (*Temporal, error) { + _r0, _err := functions.TcbufferAtCbuffer(functions.TemporalFromPointer(x.Pointer()), functions.CbufferFromPointer(cb.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtGeom is MEOS tcbuffer_at_geom. +func (x *TCbuffer) AtGeom(gs *TRGeometrySeqSet) (*Temporal, error) { + _r0, _err := functions.TcbufferAtGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtStbox is MEOS tcbuffer_at_stbox. +func (x *TCbuffer) AtStbox(box *STBox, border_inc bool) (*Temporal, error) { + _r0, _err := functions.TcbufferAtSTBOX(functions.TemporalFromPointer(x.Pointer()), functions.STBoxFromPointer(box.Pointer()), border_inc) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusCbuffer is MEOS tcbuffer_minus_cbuffer. +func (x *TCbuffer) MinusCbuffer(cb *Cbuffer) (*Temporal, error) { + _r0, _err := functions.TcbufferMinusCbuffer(functions.TemporalFromPointer(x.Pointer()), functions.CbufferFromPointer(cb.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusGeom is MEOS tcbuffer_minus_geom. +func (x *TCbuffer) MinusGeom(gs *TRGeometrySeqSet) (*Temporal, error) { + _r0, _err := functions.TcbufferMinusGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusStbox is MEOS tcbuffer_minus_stbox. +func (x *TCbuffer) MinusStbox(box *STBox, border_inc bool) (*Temporal, error) { + _r0, _err := functions.TcbufferMinusSTBOX(functions.TemporalFromPointer(x.Pointer()), functions.STBoxFromPointer(box.Pointer()), border_inc) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tcbufferinst.go b/types/tcbufferinst.go new file mode 100644 index 0000000..ab617ce --- /dev/null +++ b/types/tcbufferinst.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TCbufferInst struct { + handle +} + +// TCbufferInstFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TCbufferInstFromPointer(p unsafe.Pointer) *TCbufferInst { + if p == nil { + return nil + } + v := &TCbufferInst{} + v.ptr = p + return v +} + +// TCbufferInstMake is MEOS tcbufferinst_make. +func TCbufferInstMake(cb *Cbuffer, t int64) (*Temporal, error) { + _r0, _err := functions.TcbufferinstMake(functions.CbufferFromPointer(cb.Pointer()), t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tcbufferseq.go b/types/tcbufferseq.go new file mode 100644 index 0000000..a26ef1b --- /dev/null +++ b/types/tcbufferseq.go @@ -0,0 +1,42 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TCbufferSeq struct { + handle +} + +// TCbufferSeqFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TCbufferSeqFromPointer(p unsafe.Pointer) *TCbufferSeq { + if p == nil { + return nil + } + v := &TCbufferSeq{} + v.ptr = p + return v +} + +// TCbufferSeqFromBaseTstzset is MEOS tcbufferseq_from_base_tstzset. +func TCbufferSeqFromBaseTstzset(cb *Cbuffer, s *Set) (*Temporal, error) { + _r0, _err := functions.TcbufferseqFromBaseTstzset(functions.CbufferFromPointer(cb.Pointer()), functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TCbufferSeqFromBaseTstzspan is MEOS tcbufferseq_from_base_tstzspan. +func TCbufferSeqFromBaseTstzspan(cb *Cbuffer, s *Span, interp functions.Interpolation) (*Temporal, error) { + _r0, _err := functions.TcbufferseqFromBaseTstzspan(functions.CbufferFromPointer(cb.Pointer()), functions.SpanFromPointer(s.Pointer()), interp) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tcbufferseqset.go b/types/tcbufferseqset.go new file mode 100644 index 0000000..78b1845 --- /dev/null +++ b/types/tcbufferseqset.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TCbufferSeqSet struct { + handle +} + +// TCbufferSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TCbufferSeqSetFromPointer(p unsafe.Pointer) *TCbufferSeqSet { + if p == nil { + return nil + } + v := &TCbufferSeqSet{} + v.ptr = p + return v +} + +// TCbufferSeqSetFromBaseTstzspanset is MEOS tcbufferseqset_from_base_tstzspanset. +func TCbufferSeqSetFromBaseTstzspanset(cb *Cbuffer, ss *SpanSet, interp functions.Interpolation) (*Temporal, error) { + _r0, _err := functions.TcbufferseqsetFromBaseTstzspanset(functions.CbufferFromPointer(cb.Pointer()), functions.SpanSetFromPointer(ss.Pointer()), interp) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/temporal.go b/types/temporal.go new file mode 100644 index 0000000..feb840f --- /dev/null +++ b/types/temporal.go @@ -0,0 +1,776 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +// Temporal is superclass of every temporal type; temporal_* functions are late-bound over `subtype` and `temptype`. + +type Temporal struct { + handle +} + +// TemporalFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TemporalFromPointer(p unsafe.Pointer) *Temporal { + if p == nil { + return nil + } + v := &Temporal{} + v.ptr = p + return v +} + +// 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) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// AsMFJSON is MEOS temporal_as_mfjson. +func (x *Temporal) AsMFJSON(with_bbox bool, flags int, precision int, srs string) (string, error) { + _r0, _err := functions.TemporalAsMFJSON(functions.TemporalFromPointer(x.Pointer()), with_bbox, flags, precision, srs) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// 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) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// TemporalFromHEXWKB is MEOS temporal_from_hexwkb. +func TemporalFromHEXWKB(hexwkb string) (*Temporal, error) { + _r0, _err := functions.TemporalFromHexwkb(hexwkb) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TemporalFromWKB is MEOS temporal_from_wkb. +func TemporalFromWKB(wkb unsafe.Pointer, size uint) (*Temporal, error) { + _r0, _err := functions.TemporalFromWKB(wkb, size) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Copy is MEOS temporal_copy. +func (x *Temporal) Copy() (*Temporal, error) { + _r0, _err := functions.TemporalCopy(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTstzspan is MEOS temporal_to_tstzspan. +func (x *Temporal) ToTstzspan() (*Span, error) { + _r0, _err := functions.TemporalToTstzspan(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// EndInstant is MEOS temporal_end_instant. +func (x *Temporal) EndInstant() (*Temporal, error) { + _r0, _err := functions.TemporalEndInstant(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// EndSequence is MEOS temporal_end_sequence. +func (x *Temporal) EndSequence() (*Temporal, error) { + _r0, _err := functions.TemporalEndSequence(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// EndTimestamptz is MEOS temporal_end_timestamptz. +func (x *Temporal) EndTimestamptz() (int64, error) { + _r0, _err := functions.TemporalEndTimestamptz(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Hash is MEOS temporal_hash. +func (x *Temporal) Hash() (uint32, error) { + _r0, _err := functions.TemporalHash(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// HashExtended is MEOS temporal_hash_extended. +func (x *Temporal) HashExtended(seed uint64) (uint64, error) { + _r0, _err := functions.TemporalHashExtended(functions.TemporalFromPointer(x.Pointer()), seed) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// InstantN is MEOS temporal_instant_n. +func (x *Temporal) InstantN(n int) (*Temporal, error) { + _r0, _err := functions.TemporalInstantN(functions.TemporalFromPointer(x.Pointer()), n) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Instants is MEOS temporal_instants. +func (x *Temporal) Instants(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TemporalInstants(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Interp is MEOS temporal_interp. +func (x *Temporal) Interp() (string, error) { + _r0, _err := functions.TemporalInterp(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// LowerInc is MEOS temporal_lower_inc. +func (x *Temporal) LowerInc() (bool, error) { + _r0, _err := functions.TemporalLowerInc(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// MaxInstant is MEOS temporal_max_instant. +func (x *Temporal) MaxInstant() (*Temporal, error) { + _r0, _err := functions.TemporalMaxInstant(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinInstant is MEOS temporal_min_instant. +func (x *Temporal) MinInstant() (*Temporal, error) { + _r0, _err := functions.TemporalMinInstant(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// NumInstants is MEOS temporal_num_instants. +func (x *Temporal) NumInstants() (int, error) { + _r0, _err := functions.TemporalNumInstants(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// NumSequences is MEOS temporal_num_sequences. +func (x *Temporal) NumSequences() (int, error) { + _r0, _err := functions.TemporalNumSequences(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// NumTimestamps is MEOS temporal_num_timestamps. +func (x *Temporal) NumTimestamps() (int, error) { + _r0, _err := functions.TemporalNumTimestamps(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Segments is MEOS temporal_segments. +func (x *Temporal) Segments(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TemporalSegments(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// SequenceN is MEOS temporal_sequence_n. +func (x *Temporal) SequenceN(i int) (*Temporal, error) { + _r0, _err := functions.TemporalSequenceN(functions.TemporalFromPointer(x.Pointer()), i) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Sequences is MEOS temporal_sequences. +func (x *Temporal) Sequences(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TemporalSequences(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// StartInstant is MEOS temporal_start_instant. +func (x *Temporal) StartInstant() (*Temporal, error) { + _r0, _err := functions.TemporalStartInstant(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// StartSequence is MEOS temporal_start_sequence. +func (x *Temporal) StartSequence() (*Temporal, error) { + _r0, _err := functions.TemporalStartSequence(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// StartTimestamptz is MEOS temporal_start_timestamptz. +func (x *Temporal) StartTimestamptz() (int64, error) { + _r0, _err := functions.TemporalStartTimestamptz(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Subtype is MEOS temporal_subtype. +func (x *Temporal) Subtype() (string, error) { + _r0, _err := functions.TemporalSubtype(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// BasetypeName is MEOS temporal_basetype_name. +func (x *Temporal) BasetypeName() (string, error) { + _r0, _err := functions.TemporalBasetypeName(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// Time is MEOS temporal_time. +func (x *Temporal) Time() (*SpanSet, error) { + _r0, _err := functions.TemporalTime(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// Timestamps is MEOS temporal_timestamps. +func (x *Temporal) Timestamps(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TemporalTimestamps(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// TimestamptzN is MEOS temporal_timestamptz_n. +func (x *Temporal) TimestamptzN(n int) (int64, bool, error) { + _found, _value, _err := functions.TemporalTimestamptzN(functions.TemporalFromPointer(x.Pointer()), n) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// UpperInc is MEOS temporal_upper_inc. +func (x *Temporal) UpperInc() (bool, error) { + _r0, _err := functions.TemporalUpperInc(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Round is MEOS temporal_round. +func (x *Temporal) Round(maxdd int) (*Temporal, error) { + _r0, _err := functions.TemporalRound(functions.TemporalFromPointer(x.Pointer()), maxdd) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// SetInterp is MEOS temporal_set_interp. +func (x *Temporal) SetInterp(interp functions.Interpolation) (*Temporal, error) { + _r0, _err := functions.TemporalSetInterp(functions.TemporalFromPointer(x.Pointer()), interp) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AsTinstant is MEOS temporal_as_tinstant. +func (x *Temporal) AsTinstant() (*Temporal, error) { + _r0, _err := functions.TemporalAsTinstant(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AsTsequence is MEOS temporal_as_tsequence. +func (x *Temporal) AsTsequence(interp functions.Interpolation) (*Temporal, error) { + _r0, _err := functions.TemporalAsTsequence(functions.TemporalFromPointer(x.Pointer()), interp) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AsTsequenceset is MEOS temporal_as_tsequenceset. +func (x *Temporal) AsTsequenceset(interp functions.Interpolation) (*Temporal, error) { + _r0, _err := functions.TemporalAsTsequenceset(functions.TemporalFromPointer(x.Pointer()), interp) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AppendTsequence is MEOS temporal_append_tsequence. +func (x *Temporal) AppendTsequence(seq *Temporal, expand bool) (*Temporal, error) { + _r0, _err := functions.TemporalAppendTsequence(functions.TemporalFromPointer(x.Pointer()), functions.TSequenceFromPointer(seq.Pointer()), expand) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// DeleteTimestamptz is MEOS temporal_delete_timestamptz. +func (x *Temporal) DeleteTimestamptz(t int64, connect bool) (*Temporal, error) { + _r0, _err := functions.TemporalDeleteTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, connect) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// DeleteTstzset is MEOS temporal_delete_tstzset. +func (x *Temporal) DeleteTstzset(s *Set, connect bool) (*Temporal, error) { + _r0, _err := functions.TemporalDeleteTstzset(functions.TemporalFromPointer(x.Pointer()), functions.SetFromPointer(s.Pointer()), connect) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// DeleteTstzspan is MEOS temporal_delete_tstzspan. +func (x *Temporal) DeleteTstzspan(s *Span, connect bool) (*Temporal, error) { + _r0, _err := functions.TemporalDeleteTstzspan(functions.TemporalFromPointer(x.Pointer()), functions.SpanFromPointer(s.Pointer()), connect) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// DeleteTstzspanset is MEOS temporal_delete_tstzspanset. +func (x *Temporal) DeleteTstzspanset(ss *SpanSet, connect bool) (*Temporal, error) { + _r0, _err := functions.TemporalDeleteTstzspanset(functions.TemporalFromPointer(x.Pointer()), functions.SpanSetFromPointer(ss.Pointer()), connect) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Insert is MEOS temporal_insert. +func (x *Temporal) Insert(temp2 *Temporal, connect bool) (*Temporal, error) { + _r0, _err := functions.TemporalInsert(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer()), connect) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Merge is MEOS temporal_merge. +func (x *Temporal) Merge(temp2 *Temporal) (*Temporal, error) { + _r0, _err := functions.TemporalMerge(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TemporalMergeArray is MEOS temporal_merge_array. +func TemporalMergeArray(temparr unsafe.Pointer, count int) (*Temporal, error) { + _r0, _err := functions.TemporalMergeArray(temparr, count) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Update is MEOS temporal_update. +func (x *Temporal) Update(temp2 *Temporal, connect bool) (*Temporal, error) { + _r0, _err := functions.TemporalUpdate(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer()), connect) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AfterTimestamptz is MEOS temporal_after_timestamptz. +func (x *Temporal) AfterTimestamptz(t int64, strict bool) (*Temporal, error) { + _r0, _err := functions.TemporalAfterTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, strict) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtMax is MEOS temporal_at_max. +func (x *Temporal) AtMax() (*Temporal, error) { + _r0, _err := functions.TemporalAtMax(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtMin is MEOS temporal_at_min. +func (x *Temporal) AtMin() (*Temporal, error) { + _r0, _err := functions.TemporalAtMin(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtTimestamptz is MEOS temporal_at_timestamptz. +func (x *Temporal) AtTimestamptz(t int64) (*Temporal, error) { + _r0, _err := functions.TemporalAtTimestamptz(functions.TemporalFromPointer(x.Pointer()), t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtTstzset is MEOS temporal_at_tstzset. +func (x *Temporal) AtTstzset(s *Set) (*Temporal, error) { + _r0, _err := functions.TemporalAtTstzset(functions.TemporalFromPointer(x.Pointer()), functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtTstzspan is MEOS temporal_at_tstzspan. +func (x *Temporal) AtTstzspan(s *Span) (*Temporal, error) { + _r0, _err := functions.TemporalAtTstzspan(functions.TemporalFromPointer(x.Pointer()), functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtTstzspanset is MEOS temporal_at_tstzspanset. +func (x *Temporal) AtTstzspanset(ss *SpanSet) (*Temporal, error) { + _r0, _err := functions.TemporalAtTstzspanset(functions.TemporalFromPointer(x.Pointer()), functions.SpanSetFromPointer(ss.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtValues is MEOS temporal_at_values. +func (x *Temporal) AtValues(set *Set) (*Temporal, error) { + _r0, _err := functions.TemporalAtValues(functions.TemporalFromPointer(x.Pointer()), functions.SetFromPointer(set.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// BeforeTimestamptz is MEOS temporal_before_timestamptz. +func (x *Temporal) BeforeTimestamptz(t int64, strict bool) (*Temporal, error) { + _r0, _err := functions.TemporalBeforeTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, strict) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusMax is MEOS temporal_minus_max. +func (x *Temporal) MinusMax() (*Temporal, error) { + _r0, _err := functions.TemporalMinusMax(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusMin is MEOS temporal_minus_min. +func (x *Temporal) MinusMin() (*Temporal, error) { + _r0, _err := functions.TemporalMinusMin(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusTimestamptz is MEOS temporal_minus_timestamptz. +func (x *Temporal) MinusTimestamptz(t int64) (*Temporal, error) { + _r0, _err := functions.TemporalMinusTimestamptz(functions.TemporalFromPointer(x.Pointer()), t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusTstzset is MEOS temporal_minus_tstzset. +func (x *Temporal) MinusTstzset(s *Set) (*Temporal, error) { + _r0, _err := functions.TemporalMinusTstzset(functions.TemporalFromPointer(x.Pointer()), functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusTstzspan is MEOS temporal_minus_tstzspan. +func (x *Temporal) MinusTstzspan(s *Span) (*Temporal, error) { + _r0, _err := functions.TemporalMinusTstzspan(functions.TemporalFromPointer(x.Pointer()), functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusTstzspanset is MEOS temporal_minus_tstzspanset. +func (x *Temporal) MinusTstzspanset(ss *SpanSet) (*Temporal, error) { + _r0, _err := functions.TemporalMinusTstzspanset(functions.TemporalFromPointer(x.Pointer()), functions.SpanSetFromPointer(ss.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusValues is MEOS temporal_minus_values. +func (x *Temporal) MinusValues(set *Set) (*Temporal, error) { + _r0, _err := functions.TemporalMinusValues(functions.TemporalFromPointer(x.Pointer()), functions.SetFromPointer(set.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Cmp is MEOS temporal_cmp. +func (x *Temporal) Cmp(temp2 *Temporal) (int, error) { + _r0, _err := functions.TemporalCmp(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Eq is MEOS temporal_eq. +func (x *Temporal) Eq(temp2 *Temporal) (bool, error) { + _r0, _err := functions.TemporalEq(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Ge is MEOS temporal_ge. +func (x *Temporal) Ge(temp2 *Temporal) (bool, error) { + _r0, _err := functions.TemporalGe(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Gt is MEOS temporal_gt. +func (x *Temporal) Gt(temp2 *Temporal) (bool, error) { + _r0, _err := functions.TemporalGt(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Le is MEOS temporal_le. +func (x *Temporal) Le(temp2 *Temporal) (bool, error) { + _r0, _err := functions.TemporalLe(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Lt is MEOS temporal_lt. +func (x *Temporal) Lt(temp2 *Temporal) (bool, error) { + _r0, _err := functions.TemporalLt(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Ne is MEOS temporal_ne. +func (x *Temporal) Ne(temp2 *Temporal) (bool, error) { + _r0, _err := functions.TemporalNe(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Spans is MEOS temporal_spans. +func (x *Temporal) Spans(count unsafe.Pointer) (*Span, error) { + _r0, _err := functions.TemporalSpans(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// SplitEachNSpans is MEOS temporal_split_each_n_spans. +func (x *Temporal) SplitEachNSpans(elem_count int, count unsafe.Pointer) (*Span, error) { + _r0, _err := functions.TemporalSplitEachNSpans(functions.TemporalFromPointer(x.Pointer()), elem_count, count) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// SplitNSpans is MEOS temporal_split_n_spans. +func (x *Temporal) SplitNSpans(span_count int, count unsafe.Pointer) (*Span, error) { + _r0, _err := functions.TemporalSplitNSpans(functions.TemporalFromPointer(x.Pointer()), span_count, count) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Derivative is MEOS temporal_derivative. +func (x *Temporal) Derivative() (*Temporal, error) { + _r0, _err := functions.TemporalDerivative(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// SimplifyDp is MEOS temporal_simplify_dp. +func (x *Temporal) SimplifyDp(dist float64, synchronized bool) (*Temporal, error) { + _r0, _err := functions.TemporalSimplifyDp(functions.TemporalFromPointer(x.Pointer()), dist, synchronized) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// SimplifyMaxDist is MEOS temporal_simplify_max_dist. +func (x *Temporal) SimplifyMaxDist(dist float64, synchronized bool) (*Temporal, error) { + _r0, _err := functions.TemporalSimplifyMaxDist(functions.TemporalFromPointer(x.Pointer()), dist, synchronized) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// SimplifyMinDist is MEOS temporal_simplify_min_dist. +func (x *Temporal) SimplifyMinDist(dist float64) (*Temporal, error) { + _r0, _err := functions.TemporalSimplifyMinDist(functions.TemporalFromPointer(x.Pointer()), dist) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// DyntimewarpDistance is MEOS temporal_dyntimewarp_distance. +func (x *Temporal) DyntimewarpDistance(temp2 *Temporal) (float64, error) { + _r0, _err := functions.TemporalDyntimewarpDistance(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// FrechetDistance is MEOS temporal_frechet_distance. +func (x *Temporal) FrechetDistance(temp2 *Temporal) (float64, error) { + _r0, _err := functions.TemporalFrechetDistance(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// HausdorffDistance is MEOS temporal_hausdorff_distance. +func (x *Temporal) HausdorffDistance(temp2 *Temporal) (float64, error) { + _r0, _err := functions.TemporalHausdorffDistance(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// AverageHausdorffDistance is MEOS temporal_average_hausdorff_distance. +func (x *Temporal) AverageHausdorffDistance(temp2 *Temporal) (float64, error) { + _r0, _err := functions.TemporalAverageHausdorffDistance(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// LcssDistance is MEOS temporal_lcss_distance. +func (x *Temporal) LcssDistance(temp2 *Temporal, epsilon float64) (float64, error) { + _r0, _err := functions.TemporalLcssDistance(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer()), epsilon) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ExtKalmanFilter is MEOS temporal_ext_kalman_filter. +func (x *Temporal) ExtKalmanFilter(gate float64, q float64, variance float64, to_drop bool) (*Temporal, error) { + _r0, _err := functions.TemporalExtKalmanFilter(functions.TemporalFromPointer(x.Pointer()), gate, q, variance, to_drop) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/text.go b/types/text.go new file mode 100644 index 0000000..e4f4b78 --- /dev/null +++ b/types/text.go @@ -0,0 +1,78 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type Text struct { + Value +} + +// TextFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TextFromPointer(p unsafe.Pointer) *Text { + if p == nil { + return nil + } + v := &Text{} + v.ptr = p + return v +} + +// TextIn is MEOS text_in. +func TextIn(str string) (string, error) { + _r0, _err := functions.TextIn(str) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// TextOut is MEOS text_out. +func TextOut(txt string) (string, error) { + _r0, _err := functions.TextOut(txt) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// TextInitcap is MEOS text_initcap. +func TextInitcap(txt string) (string, error) { + _r0, _err := functions.TextInitcap(txt) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// TextLower is MEOS text_lower. +func TextLower(txt string) (string, error) { + _r0, _err := functions.TextLower(txt) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// TextUpper is MEOS text_upper. +func TextUpper(txt string) (string, error) { + _r0, _err := functions.TextUpper(txt) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// TextToSet is MEOS text_to_set. +func TextToSet(txt string) (*Set, error) { + _r0, _err := functions.TextToSet(txt) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} diff --git a/types/textset.go b/types/textset.go new file mode 100644 index 0000000..7688c77 --- /dev/null +++ b/types/textset.go @@ -0,0 +1,117 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TextSet struct { + Set +} + +// TextSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TextSetFromPointer(p unsafe.Pointer) *TextSet { + if p == nil { + return nil + } + v := &TextSet{} + v.ptr = p + return v +} + +// TextSetIn is MEOS textset_in. +func TextSetIn(str string) (*Set, error) { + _r0, _err := functions.TextsetIn(str) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS textset_out. +func (x *TextSet) Out() (string, error) { + _r0, _err := functions.TextsetOut(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// TextSetMake is MEOS textset_make. +func TextSetMake(values unsafe.Pointer, count int) (*Set, error) { + _r0, _err := functions.TextsetMake(values, count) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS textset_end_value. +func (x *TextSet) EndValue() (string, error) { + _r0, _err := functions.TextsetEndValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// StartValue is MEOS textset_start_value. +func (x *TextSet) StartValue() (string, error) { + _r0, _err := functions.TextsetStartValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// ValueN is MEOS textset_value_n. +func (x *TextSet) ValueN(n int) (string, bool, error) { + _found, _value, _err := functions.TextsetValueN(functions.SetFromPointer(x.Pointer()), n) + if _err != nil { + return "", false, _err + } + if !_found { + return "", false, nil + } + return _value, true, nil +} + +// Values is MEOS textset_values. +func (x *TextSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TextsetValues(functions.SetFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Initcap is MEOS textset_initcap. +func (x *TextSet) Initcap() (*Set, error) { + _r0, _err := functions.TextsetInitcap(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Lower is MEOS textset_lower. +func (x *TextSet) Lower() (*Set, error) { + _r0, _err := functions.TextsetLower(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Upper is MEOS textset_upper. +func (x *TextSet) Upper() (*Set, error) { + _r0, _err := functions.TextsetUpper(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} diff --git a/types/tfloat.go b/types/tfloat.go new file mode 100644 index 0000000..63ac9c4 --- /dev/null +++ b/types/tfloat.go @@ -0,0 +1,309 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TFloat struct { + TNumber +} + +// TFloatFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TFloatFromPointer(p unsafe.Pointer) *TFloat { + if p == nil { + return nil + } + v := &TFloat{} + v.ptr = p + return v +} + +// TFloatFromMFJSON is MEOS tfloat_from_mfjson. +func TFloatFromMFJSON(str string) (*Temporal, error) { + _r0, _err := functions.TfloatFromMFJSON(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TFloatIn is MEOS tfloat_in. +func TFloatIn(str string) (*Temporal, error) { + _r0, _err := functions.TfloatIn(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS tfloat_out. +func (x *TFloat) Out(maxdd int) (string, error) { + _r0, _err := functions.TfloatOut(functions.TemporalFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// TFloatFromBaseTemp is MEOS tfloat_from_base_temp. +func TFloatFromBaseTemp(d float64, temp *Temporal) (*Temporal, error) { + _r0, _err := functions.TfloatFromBaseTemp(d, functions.TemporalFromPointer(temp.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTint is MEOS tfloat_to_tint. +func (x *TFloat) ToTint() (*Temporal, error) { + _r0, _err := functions.TfloatToTint(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTbigint is MEOS tfloat_to_tbigint. +func (x *TFloat) ToTbigint() (*Temporal, error) { + _r0, _err := functions.TfloatToTbigint(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS tfloat_end_value. +func (x *TFloat) EndValue() (float64, error) { + _r0, _err := functions.TfloatEndValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// MinValue is MEOS tfloat_min_value. +func (x *TFloat) MinValue() (float64, error) { + _r0, _err := functions.TfloatMinValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// MaxValue is MEOS tfloat_max_value. +func (x *TFloat) MaxValue() (float64, error) { + _r0, _err := functions.TfloatMaxValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// StartValue is MEOS tfloat_start_value. +func (x *TFloat) StartValue() (float64, error) { + _r0, _err := functions.TfloatStartValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ValueAtTimestamptz is MEOS tfloat_value_at_timestamptz. +func (x *TFloat) ValueAtTimestamptz(t int64, strict bool) (float64, bool, error) { + _found, _value, _err := functions.TfloatValueAtTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, strict) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// ValueN is MEOS tfloat_value_n. +func (x *TFloat) ValueN(n int) (float64, bool, error) { + _found, _value, _err := functions.TfloatValueN(functions.TemporalFromPointer(x.Pointer()), n) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// Values is MEOS tfloat_values. +func (x *TFloat) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TfloatValues(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Ceil is MEOS tfloat_ceil. +func (x *TFloat) Ceil() (*Temporal, error) { + _r0, _err := functions.TfloatCeil(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Degrees is MEOS tfloat_degrees. +func (x *TFloat) Degrees(normalize bool) (*Temporal, error) { + _r0, _err := functions.TfloatDegrees(functions.TemporalFromPointer(x.Pointer()), normalize) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Floor is MEOS tfloat_floor. +func (x *TFloat) Floor() (*Temporal, error) { + _r0, _err := functions.TfloatFloor(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Radians is MEOS tfloat_radians. +func (x *TFloat) Radians() (*Temporal, error) { + _r0, _err := functions.TfloatRadians(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ScaleValue is MEOS tfloat_scale_value. +func (x *TFloat) ScaleValue(width float64) (*Temporal, error) { + _r0, _err := functions.TfloatScaleValue(functions.TemporalFromPointer(x.Pointer()), width) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ShiftScaleValue is MEOS tfloat_shift_scale_value. +func (x *TFloat) ShiftScaleValue(shift float64, width float64) (*Temporal, error) { + _r0, _err := functions.TfloatShiftScaleValue(functions.TemporalFromPointer(x.Pointer()), shift, width) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ShiftValue is MEOS tfloat_shift_value. +func (x *TFloat) ShiftValue(shift float64) (*Temporal, error) { + _r0, _err := functions.TfloatShiftValue(functions.TemporalFromPointer(x.Pointer()), shift) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtValue is MEOS tfloat_at_value. +func (x *TFloat) AtValue(d float64) (*Temporal, error) { + _r0, _err := functions.TfloatAtValue(functions.TemporalFromPointer(x.Pointer()), d) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusValue is MEOS tfloat_minus_value. +func (x *TFloat) MinusValue(d float64) (*Temporal, error) { + _r0, _err := functions.TfloatMinusValue(functions.TemporalFromPointer(x.Pointer()), d) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Exp is MEOS tfloat_exp. +func (x *TFloat) Exp() (*Temporal, error) { + _r0, _err := functions.TfloatExp(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Ln is MEOS tfloat_ln. +func (x *TFloat) Ln() (*Temporal, error) { + _r0, _err := functions.TfloatLn(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Log10 is MEOS tfloat_log10. +func (x *TFloat) Log10() (*Temporal, error) { + _r0, _err := functions.TfloatLog10(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Sin is MEOS tfloat_sin. +func (x *TFloat) Sin() (*Temporal, error) { + _r0, _err := functions.TfloatSin(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Cos is MEOS tfloat_cos. +func (x *TFloat) Cos() (*Temporal, error) { + _r0, _err := functions.TfloatCos(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Tan is MEOS tfloat_tan. +func (x *TFloat) Tan() (*Temporal, error) { + _r0, _err := functions.TfloatTan(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ValueBins is MEOS tfloat_value_bins. +func (x *TFloat) ValueBins(vsize float64, vorigin float64, count unsafe.Pointer) (*Span, error) { + _r0, _err := functions.TfloatValueBins(functions.TemporalFromPointer(x.Pointer()), vsize, vorigin, count) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// ValueBoxes is MEOS tfloat_value_boxes. +func (x *TFloat) ValueBoxes(vsize float64, vorigin float64, count unsafe.Pointer) (*TBox, error) { + _r0, _err := functions.TfloatValueBoxes(functions.TemporalFromPointer(x.Pointer()), vsize, vorigin, count) + if _err != nil { + return nil, _err + } + return TBoxFromPointer(_r0.Pointer()), nil +} + +// ValueSplit is MEOS tfloat_value_split. +func (x *TFloat) ValueSplit(size float64, origin float64, bins unsafe.Pointer, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TfloatValueSplit(functions.TemporalFromPointer(x.Pointer()), size, origin, bins, count) + if _err != nil { + return nil, _err + } + return _r0, nil +} diff --git a/types/tfloatinst.go b/types/tfloatinst.go new file mode 100644 index 0000000..c5234f7 --- /dev/null +++ b/types/tfloatinst.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TFloatInst struct { + handle +} + +// TFloatInstFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TFloatInstFromPointer(p unsafe.Pointer) *TFloatInst { + if p == nil { + return nil + } + v := &TFloatInst{} + v.ptr = p + return v +} + +// TFloatInstMake is MEOS tfloatinst_make. +func TFloatInstMake(d float64, t int64) (*Temporal, error) { + _r0, _err := functions.TfloatinstMake(d, t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tfloatseq.go b/types/tfloatseq.go new file mode 100644 index 0000000..94465c5 --- /dev/null +++ b/types/tfloatseq.go @@ -0,0 +1,42 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TFloatSeq struct { + handle +} + +// TFloatSeqFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TFloatSeqFromPointer(p unsafe.Pointer) *TFloatSeq { + if p == nil { + return nil + } + v := &TFloatSeq{} + v.ptr = p + return v +} + +// TFloatSeqFromBaseTstzset is MEOS tfloatseq_from_base_tstzset. +func TFloatSeqFromBaseTstzset(d float64, s *Set) (*Temporal, error) { + _r0, _err := functions.TfloatseqFromBaseTstzset(d, functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TFloatSeqFromBaseTstzspan is MEOS tfloatseq_from_base_tstzspan. +func TFloatSeqFromBaseTstzspan(d float64, s *Span, interp functions.Interpolation) (*Temporal, error) { + _r0, _err := functions.TfloatseqFromBaseTstzspan(d, functions.SpanFromPointer(s.Pointer()), interp) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tfloatseqset.go b/types/tfloatseqset.go new file mode 100644 index 0000000..c273222 --- /dev/null +++ b/types/tfloatseqset.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TFloatSeqSet struct { + handle +} + +// TFloatSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TFloatSeqSetFromPointer(p unsafe.Pointer) *TFloatSeqSet { + if p == nil { + return nil + } + v := &TFloatSeqSet{} + v.ptr = p + return v +} + +// TFloatSeqSetFromBaseTstzspanset is MEOS tfloatseqset_from_base_tstzspanset. +func TFloatSeqSetFromBaseTstzspanset(d float64, ss *SpanSet, interp functions.Interpolation) (*Temporal, error) { + _r0, _err := functions.TfloatseqsetFromBaseTstzspanset(d, functions.SpanSetFromPointer(ss.Pointer()), interp) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tgeo.go b/types/tgeo.go new file mode 100644 index 0000000..885ca1f --- /dev/null +++ b/types/tgeo.go @@ -0,0 +1,212 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +// TGeo is all PostGIS-derived spatiotemporal types (geometry/geography-based). Authoritative parent per MobilityDB manual Ch.7 Figure 7.1 (= the broad C predicate tgeo_type_all). NOTE: the narrower C predicate tgeo_type() and most tgeo_* functions reject points — class membership (manual) is broader than tgeo_* API applicability; see correction OM-M1. + +type TGeo struct { + TSpatial +} + +// TGeoFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TGeoFromPointer(p unsafe.Pointer) *TGeo { + if p == nil { + return nil + } + v := &TGeo{} + v.ptr = p + return v +} + +// TGeoFromBaseTemp is MEOS tgeo_from_base_temp. +func TGeoFromBaseTemp(gs *TRGeometrySeqSet, temp *Temporal) (*Temporal, error) { + _r0, _err := functions.TgeoFromBaseTemp(functions.GeomFromPointer(gs.Pointer()), functions.TemporalFromPointer(temp.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Centroid is MEOS tgeo_centroid. +func (x *TGeo) Centroid() (*Temporal, error) { + _r0, _err := functions.TgeoCentroid(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ConvexHull is MEOS tgeo_convex_hull. +func (x *TGeo) ConvexHull() (*TRGeometrySeqSet, error) { + _r0, _err := functions.TgeoConvexHull(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS tgeo_end_value. +func (x *TGeo) EndValue() (*TRGeometrySeqSet, error) { + _r0, _err := functions.TgeoEndValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// StartValue is MEOS tgeo_start_value. +func (x *TGeo) StartValue() (*TRGeometrySeqSet, error) { + _r0, _err := functions.TgeoStartValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// TraversedArea is MEOS tgeo_traversed_area. +func (x *TGeo) TraversedArea(unary_union bool) (*TRGeometrySeqSet, error) { + _r0, _err := functions.TgeoTraversedArea(functions.TemporalFromPointer(x.Pointer()), unary_union) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// ValueAtTimestamptz is MEOS tgeo_value_at_timestamptz. +func (x *TGeo) ValueAtTimestamptz(t int64, strict bool) (*TRGeometrySeqSet, bool, error) { + _found, _value, _err := functions.TgeoValueAtTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, strict) + if _err != nil { + return nil, false, _err + } + if !_found { + return nil, false, nil + } + return TRGeometrySeqSetFromPointer(_value.Pointer()), true, nil +} + +// ValueN is MEOS tgeo_value_n. +func (x *TGeo) ValueN(n int) (*TRGeometrySeqSet, bool, error) { + _found, _value, _err := functions.TgeoValueN(functions.TemporalFromPointer(x.Pointer()), n) + if _err != nil { + return nil, false, _err + } + if !_found { + return nil, false, nil + } + return TRGeometrySeqSetFromPointer(_value.Pointer()), true, nil +} + +// Values is MEOS tgeo_values. +func (x *TGeo) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TgeoValues(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Scale is MEOS tgeo_scale. +func (x *TGeo) Scale(scale *TRGeometrySeqSet, sorigin *TRGeometrySeqSet) (*Temporal, error) { + _r0, _err := functions.TgeoScale(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(scale.Pointer()), functions.GeomFromPointer(sorigin.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtGeom is MEOS tgeo_at_geom. +func (x *TGeo) AtGeom(gs *TRGeometrySeqSet) (*Temporal, error) { + _r0, _err := functions.TgeoAtGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtStbox is MEOS tgeo_at_stbox. +func (x *TGeo) AtStbox(box *STBox, border_inc bool) (*Temporal, error) { + _r0, _err := functions.TgeoAtSTBOX(functions.TemporalFromPointer(x.Pointer()), functions.STBoxFromPointer(box.Pointer()), border_inc) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtValue is MEOS tgeo_at_value. +func (x *TGeo) AtValue(gs *TRGeometrySeqSet) (*Temporal, error) { + _r0, _err := functions.TgeoAtValue(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusGeom is MEOS tgeo_minus_geom. +func (x *TGeo) MinusGeom(gs *TRGeometrySeqSet) (*Temporal, error) { + _r0, _err := functions.TgeoMinusGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusStbox is MEOS tgeo_minus_stbox. +func (x *TGeo) MinusStbox(box *STBox, border_inc bool) (*Temporal, error) { + _r0, _err := functions.TgeoMinusSTBOX(functions.TemporalFromPointer(x.Pointer()), functions.STBoxFromPointer(box.Pointer()), border_inc) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusValue is MEOS tgeo_minus_value. +func (x *TGeo) MinusValue(gs *TRGeometrySeqSet) (*Temporal, error) { + _r0, _err := functions.TgeoMinusValue(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Stboxes is MEOS tgeo_stboxes. +func (x *TGeo) Stboxes(count unsafe.Pointer) (*STBox, error) { + _r0, _err := functions.TgeoStboxes(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// SpaceBoxes is MEOS tgeo_space_boxes. +func (x *TGeo) SpaceBoxes(xsize float64, ysize float64, zsize float64, sorigin *TRGeometrySeqSet, bitmatrix bool, border_inc bool, count unsafe.Pointer) (*STBox, error) { + _r0, _err := functions.TgeoSpaceBoxes(functions.TemporalFromPointer(x.Pointer()), xsize, ysize, zsize, functions.GeomFromPointer(sorigin.Pointer()), bitmatrix, border_inc, count) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// SplitEachNStboxes is MEOS tgeo_split_each_n_stboxes. +func (x *TGeo) SplitEachNStboxes(elem_count int, count unsafe.Pointer) (*STBox, error) { + _r0, _err := functions.TgeoSplitEachNStboxes(functions.TemporalFromPointer(x.Pointer()), elem_count, count) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// SplitNStboxes is MEOS tgeo_split_n_stboxes. +func (x *TGeo) SplitNStboxes(box_count int, count unsafe.Pointer) (*STBox, error) { + _r0, _err := functions.TgeoSplitNStboxes(functions.TemporalFromPointer(x.Pointer()), box_count, count) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} diff --git a/types/tgeogpoint.go b/types/tgeogpoint.go new file mode 100644 index 0000000..00974ca --- /dev/null +++ b/types/tgeogpoint.go @@ -0,0 +1,69 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TGeogPoint struct { + TPoint +} + +// TGeogPointFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TGeogPointFromPointer(p unsafe.Pointer) *TGeogPoint { + if p == nil { + return nil + } + v := &TGeogPoint{} + v.ptr = p + return v +} + +// TGeogPointFromMFJSON is MEOS tgeogpoint_from_mfjson. +func TGeogPointFromMFJSON(str string) (*Temporal, error) { + _r0, _err := functions.TgeogpointFromMFJSON(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TGeogPointIn is MEOS tgeogpoint_in. +func TGeogPointIn(str string) (*Temporal, error) { + _r0, _err := functions.TgeogpointIn(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTgeography is MEOS tgeogpoint_to_tgeography. +func (x *TGeogPoint) ToTgeography() (*Temporal, error) { + _r0, _err := functions.TgeogpointToTgeography(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTh3index is MEOS tgeogpoint_to_th3index. +func (x *TGeogPoint) ToTh3index(resolution int32) (*Temporal, error) { + _r0, _err := functions.TgeogpointToTh3index(functions.TemporalFromPointer(x.Pointer()), resolution) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// GreatCircleDistance is MEOS tgeogpoint_great_circle_distance. +func (x *TGeogPoint) GreatCircleDistance(b *Temporal) (*Temporal, error) { + _r0, _err := functions.TgeogpointGreatCircleDistance(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(b.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tgeogpointinst.go b/types/tgeogpointinst.go new file mode 100644 index 0000000..d753a8b --- /dev/null +++ b/types/tgeogpointinst.go @@ -0,0 +1,22 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" +) + +type TGeogPointInst struct { + handle +} + +// TGeogPointInstFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TGeogPointInstFromPointer(p unsafe.Pointer) *TGeogPointInst { + if p == nil { + return nil + } + v := &TGeogPointInst{} + v.ptr = p + return v +} diff --git a/types/tgeogpointseq.go b/types/tgeogpointseq.go new file mode 100644 index 0000000..7c1f95c --- /dev/null +++ b/types/tgeogpointseq.go @@ -0,0 +1,22 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" +) + +type TGeogPointSeq struct { + handle +} + +// TGeogPointSeqFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TGeogPointSeqFromPointer(p unsafe.Pointer) *TGeogPointSeq { + if p == nil { + return nil + } + v := &TGeogPointSeq{} + v.ptr = p + return v +} diff --git a/types/tgeogpointseqset.go b/types/tgeogpointseqset.go new file mode 100644 index 0000000..54b493b --- /dev/null +++ b/types/tgeogpointseqset.go @@ -0,0 +1,22 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" +) + +type TGeogPointSeqSet struct { + handle +} + +// TGeogPointSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TGeogPointSeqSetFromPointer(p unsafe.Pointer) *TGeogPointSeqSet { + if p == nil { + return nil + } + v := &TGeogPointSeqSet{} + v.ptr = p + return v +} diff --git a/types/tgeography.go b/types/tgeography.go new file mode 100644 index 0000000..95b2b5a --- /dev/null +++ b/types/tgeography.go @@ -0,0 +1,60 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TGeography struct { + TGeo +} + +// TGeographyFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TGeographyFromPointer(p unsafe.Pointer) *TGeography { + if p == nil { + return nil + } + v := &TGeography{} + v.ptr = p + return v +} + +// TGeographyFromMFJSON is MEOS tgeography_from_mfjson. +func TGeographyFromMFJSON(mfjson string) (*Temporal, error) { + _r0, _err := functions.TgeographyFromMFJSON(mfjson) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TGeographyIn is MEOS tgeography_in. +func TGeographyIn(str string) (*Temporal, error) { + _r0, _err := functions.TgeographyIn(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTgeogpoint is MEOS tgeography_to_tgeogpoint. +func (x *TGeography) ToTgeogpoint() (*Temporal, error) { + _r0, _err := functions.TgeographyToTgeogpoint(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTgeometry is MEOS tgeography_to_tgeometry. +func (x *TGeography) ToTgeometry() (*Temporal, error) { + _r0, _err := functions.TgeographyToTgeometry(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tgeographyinst.go b/types/tgeographyinst.go new file mode 100644 index 0000000..a8f83c8 --- /dev/null +++ b/types/tgeographyinst.go @@ -0,0 +1,22 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" +) + +type TGeographyInst struct { + handle +} + +// TGeographyInstFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TGeographyInstFromPointer(p unsafe.Pointer) *TGeographyInst { + if p == nil { + return nil + } + v := &TGeographyInst{} + v.ptr = p + return v +} diff --git a/types/tgeographyseq.go b/types/tgeographyseq.go new file mode 100644 index 0000000..0876949 --- /dev/null +++ b/types/tgeographyseq.go @@ -0,0 +1,22 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" +) + +type TGeographySeq struct { + handle +} + +// TGeographySeqFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TGeographySeqFromPointer(p unsafe.Pointer) *TGeographySeq { + if p == nil { + return nil + } + v := &TGeographySeq{} + v.ptr = p + return v +} diff --git a/types/tgeographyseqset.go b/types/tgeographyseqset.go new file mode 100644 index 0000000..68c4a8d --- /dev/null +++ b/types/tgeographyseqset.go @@ -0,0 +1,22 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" +) + +type TGeographySeqSet struct { + handle +} + +// TGeographySeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TGeographySeqSetFromPointer(p unsafe.Pointer) *TGeographySeqSet { + if p == nil { + return nil + } + v := &TGeographySeqSet{} + v.ptr = p + return v +} diff --git a/types/tgeometry.go b/types/tgeometry.go new file mode 100644 index 0000000..f155a72 --- /dev/null +++ b/types/tgeometry.go @@ -0,0 +1,69 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TGeometry struct { + TGeo +} + +// TGeometryFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TGeometryFromPointer(p unsafe.Pointer) *TGeometry { + if p == nil { + return nil + } + v := &TGeometry{} + v.ptr = p + return v +} + +// TGeometryFromMFJSON is MEOS tgeometry_from_mfjson. +func TGeometryFromMFJSON(str string) (*Temporal, error) { + _r0, _err := functions.TgeometryFromMFJSON(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TGeometryIn is MEOS tgeometry_in. +func TGeometryIn(str string) (*Temporal, error) { + _r0, _err := functions.TgeometryIn(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTgeography is MEOS tgeometry_to_tgeography. +func (x *TGeometry) ToTgeography() (*Temporal, error) { + _r0, _err := functions.TgeometryToTgeography(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTgeompoint is MEOS tgeometry_to_tgeompoint. +func (x *TGeometry) ToTgeompoint() (*Temporal, error) { + _r0, _err := functions.TgeometryToTgeompoint(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTcbuffer is MEOS tgeometry_to_tcbuffer. +func (x *TGeometry) ToTcbuffer() (*Temporal, error) { + _r0, _err := functions.TgeometryToTcbuffer(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tgeometryinst.go b/types/tgeometryinst.go new file mode 100644 index 0000000..e9531c1 --- /dev/null +++ b/types/tgeometryinst.go @@ -0,0 +1,22 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" +) + +type TGeometryInst struct { + handle +} + +// TGeometryInstFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TGeometryInstFromPointer(p unsafe.Pointer) *TGeometryInst { + if p == nil { + return nil + } + v := &TGeometryInst{} + v.ptr = p + return v +} diff --git a/types/tgeometryseq.go b/types/tgeometryseq.go new file mode 100644 index 0000000..f97adc6 --- /dev/null +++ b/types/tgeometryseq.go @@ -0,0 +1,22 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" +) + +type TGeometrySeq struct { + handle +} + +// TGeometrySeqFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TGeometrySeqFromPointer(p unsafe.Pointer) *TGeometrySeq { + if p == nil { + return nil + } + v := &TGeometrySeq{} + v.ptr = p + return v +} diff --git a/types/tgeometryseqset.go b/types/tgeometryseqset.go new file mode 100644 index 0000000..2216ea5 --- /dev/null +++ b/types/tgeometryseqset.go @@ -0,0 +1,22 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" +) + +type TGeometrySeqSet struct { + handle +} + +// TGeometrySeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TGeometrySeqSetFromPointer(p unsafe.Pointer) *TGeometrySeqSet { + if p == nil { + return nil + } + v := &TGeometrySeqSet{} + v.ptr = p + return v +} diff --git a/types/tgeompoint.go b/types/tgeompoint.go new file mode 100644 index 0000000..a0a4914 --- /dev/null +++ b/types/tgeompoint.go @@ -0,0 +1,69 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TGeomPoint struct { + TPoint +} + +// TGeomPointFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TGeomPointFromPointer(p unsafe.Pointer) *TGeomPoint { + if p == nil { + return nil + } + v := &TGeomPoint{} + v.ptr = p + return v +} + +// TGeomPointFromMFJSON is MEOS tgeompoint_from_mfjson. +func TGeomPointFromMFJSON(str string) (*Temporal, error) { + _r0, _err := functions.TgeompointFromMFJSON(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TGeomPointIn is MEOS tgeompoint_in. +func TGeomPointIn(str string) (*Temporal, error) { + _r0, _err := functions.TgeompointIn(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTgeometry is MEOS tgeompoint_to_tgeometry. +func (x *TGeomPoint) ToTgeometry() (*Temporal, error) { + _r0, _err := functions.TgeompointToTgeometry(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTh3index is MEOS tgeompoint_to_th3index. +func (x *TGeomPoint) ToTh3index(resolution int32) (*Temporal, error) { + _r0, _err := functions.TgeompointToTh3index(functions.TemporalFromPointer(x.Pointer()), resolution) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTnpoint is MEOS tgeompoint_to_tnpoint. +func (x *TGeomPoint) ToTnpoint() (*Temporal, error) { + _r0, _err := functions.TgeompointToTnpoint(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tgeompointinst.go b/types/tgeompointinst.go new file mode 100644 index 0000000..63ff788 --- /dev/null +++ b/types/tgeompointinst.go @@ -0,0 +1,22 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" +) + +type TGeomPointInst struct { + handle +} + +// TGeomPointInstFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TGeomPointInstFromPointer(p unsafe.Pointer) *TGeomPointInst { + if p == nil { + return nil + } + v := &TGeomPointInst{} + v.ptr = p + return v +} diff --git a/types/tgeompointseq.go b/types/tgeompointseq.go new file mode 100644 index 0000000..08544b6 --- /dev/null +++ b/types/tgeompointseq.go @@ -0,0 +1,22 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" +) + +type TGeomPointSeq struct { + handle +} + +// TGeomPointSeqFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TGeomPointSeqFromPointer(p unsafe.Pointer) *TGeomPointSeq { + if p == nil { + return nil + } + v := &TGeomPointSeq{} + v.ptr = p + return v +} diff --git a/types/tgeompointseqset.go b/types/tgeompointseqset.go new file mode 100644 index 0000000..b9017fb --- /dev/null +++ b/types/tgeompointseqset.go @@ -0,0 +1,22 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" +) + +type TGeomPointSeqSet struct { + handle +} + +// TGeomPointSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TGeomPointSeqSetFromPointer(p unsafe.Pointer) *TGeomPointSeqSet { + if p == nil { + return nil + } + v := &TGeomPointSeqSet{} + v.ptr = p + return v +} diff --git a/types/tinstant.go b/types/tinstant.go new file mode 100644 index 0000000..72b2c3a --- /dev/null +++ b/types/tinstant.go @@ -0,0 +1,22 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" +) + +type TInstant struct { + Temporal +} + +// TInstantFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TInstantFromPointer(p unsafe.Pointer) *TInstant { + if p == nil { + return nil + } + v := &TInstant{} + v.ptr = p + return v +} diff --git a/types/tint.go b/types/tint.go new file mode 100644 index 0000000..0883ed5 --- /dev/null +++ b/types/tint.go @@ -0,0 +1,219 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TInt struct { + TNumber +} + +// TIntFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TIntFromPointer(p unsafe.Pointer) *TInt { + if p == nil { + return nil + } + v := &TInt{} + v.ptr = p + return v +} + +// TIntFromMFJSON is MEOS tint_from_mfjson. +func TIntFromMFJSON(str string) (*Temporal, error) { + _r0, _err := functions.TintFromMFJSON(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TIntIn is MEOS tint_in. +func TIntIn(str string) (*Temporal, error) { + _r0, _err := functions.TintIn(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS tint_out. +func (x *TInt) Out() (string, error) { + _r0, _err := functions.TintOut(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// TIntFromBaseTemp is MEOS tint_from_base_temp. +func TIntFromBaseTemp(i int, temp *Temporal) (*Temporal, error) { + _r0, _err := functions.TintFromBaseTemp(i, functions.TemporalFromPointer(temp.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTfloat is MEOS tint_to_tfloat. +func (x *TInt) ToTfloat() (*Temporal, error) { + _r0, _err := functions.TintToTfloat(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTbigint is MEOS tint_to_tbigint. +func (x *TInt) ToTbigint() (*Temporal, error) { + _r0, _err := functions.TintToTbigint(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS tint_end_value. +func (x *TInt) EndValue() (int, error) { + _r0, _err := functions.TintEndValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// MaxValue is MEOS tint_max_value. +func (x *TInt) MaxValue() (int, error) { + _r0, _err := functions.TintMaxValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// MinValue is MEOS tint_min_value. +func (x *TInt) MinValue() (int, error) { + _r0, _err := functions.TintMinValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// StartValue is MEOS tint_start_value. +func (x *TInt) StartValue() (int, error) { + _r0, _err := functions.TintStartValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ValueAtTimestamptz is MEOS tint_value_at_timestamptz. +func (x *TInt) ValueAtTimestamptz(t int64, strict bool) (int, bool, error) { + _found, _value, _err := functions.TintValueAtTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, strict) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// ValueN is MEOS tint_value_n. +func (x *TInt) ValueN(n int) (int, bool, error) { + _found, _value, _err := functions.TintValueN(functions.TemporalFromPointer(x.Pointer()), n) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// Values is MEOS tint_values. +func (x *TInt) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TintValues(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// ScaleValue is MEOS tint_scale_value. +func (x *TInt) ScaleValue(width int) (*Temporal, error) { + _r0, _err := functions.TintScaleValue(functions.TemporalFromPointer(x.Pointer()), width) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ShiftScaleValue is MEOS tint_shift_scale_value. +func (x *TInt) ShiftScaleValue(shift int, width int) (*Temporal, error) { + _r0, _err := functions.TintShiftScaleValue(functions.TemporalFromPointer(x.Pointer()), shift, width) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ShiftValue is MEOS tint_shift_value. +func (x *TInt) ShiftValue(shift int) (*Temporal, error) { + _r0, _err := functions.TintShiftValue(functions.TemporalFromPointer(x.Pointer()), shift) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtValue is MEOS tint_at_value. +func (x *TInt) AtValue(i int) (*Temporal, error) { + _r0, _err := functions.TintAtValue(functions.TemporalFromPointer(x.Pointer()), i) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusValue is MEOS tint_minus_value. +func (x *TInt) MinusValue(i int) (*Temporal, error) { + _r0, _err := functions.TintMinusValue(functions.TemporalFromPointer(x.Pointer()), i) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ValueBins is MEOS tint_value_bins. +func (x *TInt) ValueBins(vsize int, vorigin int, count unsafe.Pointer) (*Span, error) { + _r0, _err := functions.TintValueBins(functions.TemporalFromPointer(x.Pointer()), vsize, vorigin, count) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// ValueBoxes is MEOS tint_value_boxes. +func (x *TInt) ValueBoxes(vsize int, vorigin int, count unsafe.Pointer) (*TBox, error) { + _r0, _err := functions.TintValueBoxes(functions.TemporalFromPointer(x.Pointer()), vsize, vorigin, count) + if _err != nil { + return nil, _err + } + return TBoxFromPointer(_r0.Pointer()), nil +} + +// ValueSplit is MEOS tint_value_split. +func (x *TInt) ValueSplit(vsize int, vorigin int, bins unsafe.Pointer, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TintValueSplit(functions.TemporalFromPointer(x.Pointer()), vsize, vorigin, bins, count) + if _err != nil { + return nil, _err + } + return _r0, nil +} diff --git a/types/tintinst.go b/types/tintinst.go new file mode 100644 index 0000000..4df7898 --- /dev/null +++ b/types/tintinst.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TIntInst struct { + handle +} + +// TIntInstFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TIntInstFromPointer(p unsafe.Pointer) *TIntInst { + if p == nil { + return nil + } + v := &TIntInst{} + v.ptr = p + return v +} + +// TIntInstMake is MEOS tintinst_make. +func TIntInstMake(i int, t int64) (*Temporal, error) { + _r0, _err := functions.TintinstMake(i, t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tintseq.go b/types/tintseq.go new file mode 100644 index 0000000..dcf503c --- /dev/null +++ b/types/tintseq.go @@ -0,0 +1,42 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TIntSeq struct { + handle +} + +// TIntSeqFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TIntSeqFromPointer(p unsafe.Pointer) *TIntSeq { + if p == nil { + return nil + } + v := &TIntSeq{} + v.ptr = p + return v +} + +// TIntSeqFromBaseTstzset is MEOS tintseq_from_base_tstzset. +func TIntSeqFromBaseTstzset(i int, s *Set) (*Temporal, error) { + _r0, _err := functions.TintseqFromBaseTstzset(i, functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TIntSeqFromBaseTstzspan is MEOS tintseq_from_base_tstzspan. +func TIntSeqFromBaseTstzspan(i int, s *Span) (*Temporal, error) { + _r0, _err := functions.TintseqFromBaseTstzspan(i, functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tintseqset.go b/types/tintseqset.go new file mode 100644 index 0000000..95e28ad --- /dev/null +++ b/types/tintseqset.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TIntSeqSet struct { + handle +} + +// TIntSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TIntSeqSetFromPointer(p unsafe.Pointer) *TIntSeqSet { + if p == nil { + return nil + } + v := &TIntSeqSet{} + v.ptr = p + return v +} + +// TIntSeqSetFromBaseTstzspanset is MEOS tintseqset_from_base_tstzspanset. +func TIntSeqSetFromBaseTstzspanset(i int, ss *SpanSet) (*Temporal, error) { + _r0, _err := functions.TintseqsetFromBaseTstzspanset(i, functions.SpanSetFromPointer(ss.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tjsonb.go b/types/tjsonb.go new file mode 100644 index 0000000..8f5da67 --- /dev/null +++ b/types/tjsonb.go @@ -0,0 +1,354 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TJsonb struct { + TAlpha +} + +// TJsonbFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TJsonbFromPointer(p unsafe.Pointer) *TJsonb { + if p == nil { + return nil + } + v := &TJsonb{} + v.ptr = p + return v +} + +// TJsonbFromMFJSON is MEOS tjsonb_from_mfjson. +func TJsonbFromMFJSON(str string) (*Temporal, error) { + _r0, _err := functions.TjsonbFromMFJSON(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TJsonbIn is MEOS tjsonb_in. +func TJsonbIn(str string) (*Temporal, error) { + _r0, _err := functions.TjsonbIn(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS tjsonb_out. +func (x *TJsonb) Out() (string, error) { + _r0, _err := functions.TjsonbOut(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// TJsonbFromBaseTemp is MEOS tjsonb_from_base_temp. +func TJsonbFromBaseTemp(jsonb *Jsonb, temp *Temporal) (*Temporal, error) { + _r0, _err := functions.TjsonbFromBaseTemp(functions.JsonbFromPointer(jsonb.Pointer()), functions.TemporalFromPointer(temp.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTtext is MEOS tjsonb_to_ttext. +func (x *TJsonb) ToTtext() (*Temporal, error) { + _r0, _err := functions.TjsonbToTtext(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS tjsonb_end_value. +func (x *TJsonb) EndValue() (*Jsonb, error) { + _r0, _err := functions.TjsonbEndValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// StartValue is MEOS tjsonb_start_value. +func (x *TJsonb) StartValue() (*Jsonb, error) { + _r0, _err := functions.TjsonbStartValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// ValueAtTimestamptz is MEOS tjsonb_value_at_timestamptz. +func (x *TJsonb) ValueAtTimestamptz(t int64, strict bool) (*Jsonb, bool, error) { + _found, _value, _err := functions.TjsonbValueAtTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, strict) + if _err != nil { + return nil, false, _err + } + if !_found { + return nil, false, nil + } + return JsonbFromPointer(_value.Pointer()), true, nil +} + +// ValueN is MEOS tjsonb_value_n. +func (x *TJsonb) ValueN(n int) (*Jsonb, bool, error) { + _found, _value, _err := functions.TjsonbValueN(functions.TemporalFromPointer(x.Pointer()), n) + if _err != nil { + return nil, false, _err + } + if !_found { + return nil, false, nil + } + return JsonbFromPointer(_value.Pointer()), true, nil +} + +// Values is MEOS tjsonb_values. +func (x *TJsonb) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TjsonbValues(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// ArrayElement is MEOS tjsonb_array_element. +func (x *TJsonb) ArrayElement(idx int, astext bool, null_handle functions.NullHandleType) (*Temporal, error) { + _r0, _err := functions.TjsonbArrayElement(functions.TemporalFromPointer(x.Pointer()), idx, astext, null_handle) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ArrayLength is MEOS tjsonb_array_length. +func (x *TJsonb) ArrayLength() (*Temporal, error) { + _r0, _err := functions.TjsonbArrayLength(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Delete is MEOS tjsonb_delete. +func (x *TJsonb) Delete(key string) (*Temporal, error) { + _r0, _err := functions.TjsonbDelete(functions.TemporalFromPointer(x.Pointer()), key) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// DeleteArray is MEOS tjsonb_delete_array. +func (x *TJsonb) DeleteArray(keys unsafe.Pointer, count int) (*Temporal, error) { + _r0, _err := functions.TjsonbDeleteArray(functions.TemporalFromPointer(x.Pointer()), keys, count) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// DeleteIndex is MEOS tjsonb_delete_index. +func (x *TJsonb) DeleteIndex(idx int) (*Temporal, error) { + _r0, _err := functions.TjsonbDeleteIndex(functions.TemporalFromPointer(x.Pointer()), idx) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// DeletePath is MEOS tjsonb_delete_path. +func (x *TJsonb) DeletePath(path_elems unsafe.Pointer, path_len int) (*Temporal, error) { + _r0, _err := functions.TjsonbDeletePath(functions.TemporalFromPointer(x.Pointer()), path_elems, path_len) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Exists is MEOS tjsonb_exists. +func (x *TJsonb) Exists(key string) (*Temporal, error) { + _r0, _err := functions.TjsonbExists(functions.TemporalFromPointer(x.Pointer()), key) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ExistsAll is MEOS tjsonb_exists_all. +func (x *TJsonb) ExistsAll(keys unsafe.Pointer, count int) (*Temporal, error) { + _r0, _err := functions.TjsonbExistsAll(functions.TemporalFromPointer(x.Pointer()), keys, count) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ExistsAny is MEOS tjsonb_exists_any. +func (x *TJsonb) ExistsAny(keys unsafe.Pointer, count int) (*Temporal, error) { + _r0, _err := functions.TjsonbExistsAny(functions.TemporalFromPointer(x.Pointer()), keys, count) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ExistsArray is MEOS tjsonb_exists_array. +func (x *TJsonb) ExistsArray(keys unsafe.Pointer, count int, any bool) (*Temporal, error) { + _r0, _err := functions.TjsonbExistsArray(functions.TemporalFromPointer(x.Pointer()), keys, count, any) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ExtractPath is MEOS tjsonb_extract_path. +func (x *TJsonb) ExtractPath(path_elems unsafe.Pointer, path_len int, astext bool, null_handle functions.NullHandleType) (*Temporal, error) { + _r0, _err := functions.TjsonbExtractPath(functions.TemporalFromPointer(x.Pointer()), path_elems, path_len, astext, null_handle) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Insert is MEOS tjsonb_insert. +func (x *TJsonb) Insert(keys unsafe.Pointer, count int, newjb *Jsonb, after bool) (*Temporal, error) { + _r0, _err := functions.TjsonbInsert(functions.TemporalFromPointer(x.Pointer()), keys, count, functions.JsonbFromPointer(newjb.Pointer()), after) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ObjectField is MEOS tjsonb_object_field. +func (x *TJsonb) ObjectField(key string, astext bool, null_handle functions.NullHandleType) (*Temporal, error) { + _r0, _err := functions.TjsonbObjectField(functions.TemporalFromPointer(x.Pointer()), key, astext, null_handle) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// PathExists is MEOS tjsonb_path_exists. +func (x *TJsonb) PathExists(jp *JsonPath, vars *Jsonb, silent bool, tz bool) (*Temporal, error) { + _r0, _err := functions.TjsonbPathExists(functions.TemporalFromPointer(x.Pointer()), functions.JsonPathFromPointer(jp.Pointer()), functions.JsonbFromPointer(vars.Pointer()), silent, tz) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// PathMatch is MEOS tjsonb_path_match. +func (x *TJsonb) PathMatch(jp *JsonPath, vars *Jsonb, silent bool, tz bool) (*Temporal, error) { + _r0, _err := functions.TjsonbPathMatch(functions.TemporalFromPointer(x.Pointer()), functions.JsonPathFromPointer(jp.Pointer()), functions.JsonbFromPointer(vars.Pointer()), silent, tz) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// PathQueryArray is MEOS tjsonb_path_query_array. +func (x *TJsonb) PathQueryArray(jp *JsonPath, vars *Jsonb, silent bool, tz bool) (*Temporal, error) { + _r0, _err := functions.TjsonbPathQueryArray(functions.TemporalFromPointer(x.Pointer()), functions.JsonPathFromPointer(jp.Pointer()), functions.JsonbFromPointer(vars.Pointer()), silent, tz) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// PathQueryFirst is MEOS tjsonb_path_query_first. +func (x *TJsonb) PathQueryFirst(jp *JsonPath, vars *Jsonb, silent bool, tz bool) (*Temporal, error) { + _r0, _err := functions.TjsonbPathQueryFirst(functions.TemporalFromPointer(x.Pointer()), functions.JsonPathFromPointer(jp.Pointer()), functions.JsonbFromPointer(vars.Pointer()), silent, tz) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Pretty is MEOS tjsonb_pretty. +func (x *TJsonb) Pretty() (*Temporal, error) { + _r0, _err := functions.TjsonbPretty(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Set is MEOS tjsonb_set. +func (x *TJsonb) Set(keys unsafe.Pointer, count int, newjb *Jsonb, create bool, handle_null string, lax bool) (*Temporal, error) { + _r0, _err := functions.TjsonbSet(functions.TemporalFromPointer(x.Pointer()), keys, count, functions.JsonbFromPointer(newjb.Pointer()), create, handle_null, lax) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// StripNulls is MEOS tjsonb_strip_nulls. +func (x *TJsonb) StripNulls(strip_in_arrays bool) (*Temporal, error) { + _r0, _err := functions.TjsonbStripNulls(functions.TemporalFromPointer(x.Pointer()), strip_in_arrays) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTbool is MEOS tjsonb_to_tbool. +func (x *TJsonb) ToTbool(key string, null_handle functions.NullHandleType) (*Temporal, error) { + _r0, _err := functions.TjsonbToTbool(functions.TemporalFromPointer(x.Pointer()), key, null_handle) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTfloat is MEOS tjsonb_to_tfloat. +func (x *TJsonb) ToTfloat(key string, interp functions.Interpolation, null_handle functions.NullHandleType) (*Temporal, error) { + _r0, _err := functions.TjsonbToTfloat(functions.TemporalFromPointer(x.Pointer()), key, interp, null_handle) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTint is MEOS tjsonb_to_tint. +func (x *TJsonb) ToTint(key string, null_handle functions.NullHandleType) (*Temporal, error) { + _r0, _err := functions.TjsonbToTint(functions.TemporalFromPointer(x.Pointer()), key, null_handle) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTtextKey is MEOS tjsonb_to_ttext_key. +func (x *TJsonb) ToTtextKey(key string, null_handle functions.NullHandleType) (*Temporal, error) { + _r0, _err := functions.TjsonbToTtextKey(functions.TemporalFromPointer(x.Pointer()), key, null_handle) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtValue is MEOS tjsonb_at_value. +func (x *TJsonb) AtValue(jsb *Jsonb) (*Temporal, error) { + _r0, _err := functions.TjsonbAtValue(functions.TemporalFromPointer(x.Pointer()), functions.JsonbFromPointer(jsb.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusValue is MEOS tjsonb_minus_value. +func (x *TJsonb) MinusValue(jsb *Jsonb) (*Temporal, error) { + _r0, _err := functions.TjsonbMinusValue(functions.TemporalFromPointer(x.Pointer()), functions.JsonbFromPointer(jsb.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tjsonbinst.go b/types/tjsonbinst.go new file mode 100644 index 0000000..8323647 --- /dev/null +++ b/types/tjsonbinst.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TJsonbInst struct { + handle +} + +// TJsonbInstFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TJsonbInstFromPointer(p unsafe.Pointer) *TJsonbInst { + if p == nil { + return nil + } + v := &TJsonbInst{} + v.ptr = p + return v +} + +// TJsonbInstMake is MEOS tjsonbinst_make. +func TJsonbInstMake(jsonb *Jsonb, t int64) (*Temporal, error) { + _r0, _err := functions.TjsonbinstMake(functions.JsonbFromPointer(jsonb.Pointer()), t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tjsonbseq.go b/types/tjsonbseq.go new file mode 100644 index 0000000..cbea172 --- /dev/null +++ b/types/tjsonbseq.go @@ -0,0 +1,42 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TJsonbSeq struct { + handle +} + +// TJsonbSeqFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TJsonbSeqFromPointer(p unsafe.Pointer) *TJsonbSeq { + if p == nil { + return nil + } + v := &TJsonbSeq{} + v.ptr = p + return v +} + +// TJsonbSeqFromBaseTstzset is MEOS tjsonbseq_from_base_tstzset. +func TJsonbSeqFromBaseTstzset(jsonb *Jsonb, s *Set) (*Temporal, error) { + _r0, _err := functions.TjsonbseqFromBaseTstzset(functions.JsonbFromPointer(jsonb.Pointer()), functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TJsonbSeqFromBaseTstzspan is MEOS tjsonbseq_from_base_tstzspan. +func TJsonbSeqFromBaseTstzspan(jsonb *Jsonb, sp *Span) (*Temporal, error) { + _r0, _err := functions.TjsonbseqFromBaseTstzspan(functions.JsonbFromPointer(jsonb.Pointer()), functions.SpanFromPointer(sp.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tjsonbseqset.go b/types/tjsonbseqset.go new file mode 100644 index 0000000..e54b689 --- /dev/null +++ b/types/tjsonbseqset.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TJsonbSeqSet struct { + handle +} + +// TJsonbSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TJsonbSeqSetFromPointer(p unsafe.Pointer) *TJsonbSeqSet { + if p == nil { + return nil + } + v := &TJsonbSeqSet{} + v.ptr = p + return v +} + +// TJsonbSeqSetFromBaseTstzspanset is MEOS tjsonbseqset_from_base_tstzspanset. +func TJsonbSeqSetFromBaseTstzspanset(jsonb *Jsonb, ss *SpanSet) (*Temporal, error) { + _r0, _err := functions.TjsonbseqsetFromBaseTstzspanset(functions.JsonbFromPointer(jsonb.Pointer()), functions.SpanSetFromPointer(ss.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tnpoint.go b/types/tnpoint.go new file mode 100644 index 0000000..6782993 --- /dev/null +++ b/types/tnpoint.go @@ -0,0 +1,264 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TNpoint struct { + TSpatial +} + +// TNpointFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TNpointFromPointer(p unsafe.Pointer) *TNpoint { + if p == nil { + return nil + } + v := &TNpoint{} + v.ptr = p + return v +} + +// TNpointIn is MEOS tnpoint_in. +func TNpointIn(str string) (*Temporal, error) { + _r0, _err := functions.TnpointIn(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TNpointFromMFJSON is MEOS tnpoint_from_mfjson. +func TNpointFromMFJSON(mfjson string) (*Temporal, error) { + _r0, _err := functions.TnpointFromMFJSON(mfjson) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS tnpoint_out. +func (x *TNpoint) Out(maxdd int) (string, error) { + _r0, _err := functions.TnpointOut(functions.TemporalFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// TNpointFromBaseTemp is MEOS tnpoint_from_base_temp. +func TNpointFromBaseTemp(np *Npoint, temp *Temporal) (*Temporal, error) { + _r0, _err := functions.TnpointFromBaseTemp(functions.NpointFromPointer(np.Pointer()), functions.TemporalFromPointer(temp.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTgeompoint is MEOS tnpoint_to_tgeompoint. +func (x *TNpoint) ToTgeompoint() (*Temporal, error) { + _r0, _err := functions.TnpointToTgeompoint(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// CumulativeLength is MEOS tnpoint_cumulative_length. +func (x *TNpoint) CumulativeLength() (*Temporal, error) { + _r0, _err := functions.TnpointCumulativeLength(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS tnpoint_end_value. +func (x *TNpoint) EndValue() (*Npoint, error) { + _r0, _err := functions.TnpointEndValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return NpointFromPointer(_r0.Pointer()), nil +} + +// Length is MEOS tnpoint_length. +func (x *TNpoint) Length() (float64, error) { + _r0, _err := functions.TnpointLength(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Positions is MEOS tnpoint_positions. +func (x *TNpoint) Positions(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TnpointPositions(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Route is MEOS tnpoint_route. +func (x *TNpoint) Route() (int64, error) { + _r0, _err := functions.TnpointRoute(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Routes is MEOS tnpoint_routes. +func (x *TNpoint) Routes() (*Set, error) { + _r0, _err := functions.TnpointRoutes(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Speed is MEOS tnpoint_speed. +func (x *TNpoint) Speed() (*Temporal, error) { + _r0, _err := functions.TnpointSpeed(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// StartValue is MEOS tnpoint_start_value. +func (x *TNpoint) StartValue() (*Npoint, error) { + _r0, _err := functions.TnpointStartValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return NpointFromPointer(_r0.Pointer()), nil +} + +// Trajectory is MEOS tnpoint_trajectory. +func (x *TNpoint) Trajectory() (*TRGeometrySeqSet, error) { + _r0, _err := functions.TnpointTrajectory(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// ValueAtTimestamptz is MEOS tnpoint_value_at_timestamptz. +func (x *TNpoint) ValueAtTimestamptz(t int64, strict bool) (*Npoint, bool, error) { + _found, _value, _err := functions.TnpointValueAtTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, strict) + if _err != nil { + return nil, false, _err + } + if !_found { + return nil, false, nil + } + return NpointFromPointer(_value.Pointer()), true, nil +} + +// ValueN is MEOS tnpoint_value_n. +func (x *TNpoint) ValueN(n int) (*Npoint, bool, error) { + _found, _value, _err := functions.TnpointValueN(functions.TemporalFromPointer(x.Pointer()), n) + if _err != nil { + return nil, false, _err + } + if !_found { + return nil, false, nil + } + return NpointFromPointer(_value.Pointer()), true, nil +} + +// Values is MEOS tnpoint_values. +func (x *TNpoint) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TnpointValues(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Twcentroid is MEOS tnpoint_twcentroid. +func (x *TNpoint) Twcentroid() (*TRGeometrySeqSet, error) { + _r0, _err := functions.TnpointTwcentroid(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// AtGeom is MEOS tnpoint_at_geom. +func (x *TNpoint) AtGeom(gs *TRGeometrySeqSet) (*Temporal, error) { + _r0, _err := functions.TnpointAtGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtNpoint is MEOS tnpoint_at_npoint. +func (x *TNpoint) AtNpoint(np *Npoint) (*Temporal, error) { + _r0, _err := functions.TnpointAtNpoint(functions.TemporalFromPointer(x.Pointer()), functions.NpointFromPointer(np.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtNpointset is MEOS tnpoint_at_npointset. +func (x *TNpoint) AtNpointset(s *Set) (*Temporal, error) { + _r0, _err := functions.TnpointAtNpointset(functions.TemporalFromPointer(x.Pointer()), functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtStbox is MEOS tnpoint_at_stbox. +func (x *TNpoint) AtStbox(box *STBox, border_inc bool) (*Temporal, error) { + _r0, _err := functions.TnpointAtSTBOX(functions.TemporalFromPointer(x.Pointer()), functions.STBoxFromPointer(box.Pointer()), border_inc) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusGeom is MEOS tnpoint_minus_geom. +func (x *TNpoint) MinusGeom(gs *TRGeometrySeqSet) (*Temporal, error) { + _r0, _err := functions.TnpointMinusGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusNpoint is MEOS tnpoint_minus_npoint. +func (x *TNpoint) MinusNpoint(np *Npoint) (*Temporal, error) { + _r0, _err := functions.TnpointMinusNpoint(functions.TemporalFromPointer(x.Pointer()), functions.NpointFromPointer(np.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusNpointset is MEOS tnpoint_minus_npointset. +func (x *TNpoint) MinusNpointset(s *Set) (*Temporal, error) { + _r0, _err := functions.TnpointMinusNpointset(functions.TemporalFromPointer(x.Pointer()), functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusStbox is MEOS tnpoint_minus_stbox. +func (x *TNpoint) MinusStbox(box *STBox, border_inc bool) (*Temporal, error) { + _r0, _err := functions.TnpointMinusSTBOX(functions.TemporalFromPointer(x.Pointer()), functions.STBoxFromPointer(box.Pointer()), border_inc) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tnpointinst.go b/types/tnpointinst.go new file mode 100644 index 0000000..dbe55ac --- /dev/null +++ b/types/tnpointinst.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TNpointInst struct { + handle +} + +// TNpointInstFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TNpointInstFromPointer(p unsafe.Pointer) *TNpointInst { + if p == nil { + return nil + } + v := &TNpointInst{} + v.ptr = p + return v +} + +// TNpointInstMake is MEOS tnpointinst_make. +func TNpointInstMake(np *Npoint, t int64) (*Temporal, error) { + _r0, _err := functions.TnpointinstMake(functions.NpointFromPointer(np.Pointer()), t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tnpointseq.go b/types/tnpointseq.go new file mode 100644 index 0000000..69ef39a --- /dev/null +++ b/types/tnpointseq.go @@ -0,0 +1,42 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TNpointSeq struct { + handle +} + +// TNpointSeqFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TNpointSeqFromPointer(p unsafe.Pointer) *TNpointSeq { + if p == nil { + return nil + } + v := &TNpointSeq{} + v.ptr = p + return v +} + +// TNpointSeqFromBaseTstzset is MEOS tnpointseq_from_base_tstzset. +func TNpointSeqFromBaseTstzset(np *Npoint, s *Set) (*Temporal, error) { + _r0, _err := functions.TnpointseqFromBaseTstzset(functions.NpointFromPointer(np.Pointer()), functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TNpointSeqFromBaseTstzspan is MEOS tnpointseq_from_base_tstzspan. +func TNpointSeqFromBaseTstzspan(np *Npoint, s *Span, interp functions.Interpolation) (*Temporal, error) { + _r0, _err := functions.TnpointseqFromBaseTstzspan(functions.NpointFromPointer(np.Pointer()), functions.SpanFromPointer(s.Pointer()), interp) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tnpointseqset.go b/types/tnpointseqset.go new file mode 100644 index 0000000..a8478a9 --- /dev/null +++ b/types/tnpointseqset.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TNpointSeqSet struct { + handle +} + +// TNpointSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TNpointSeqSetFromPointer(p unsafe.Pointer) *TNpointSeqSet { + if p == nil { + return nil + } + v := &TNpointSeqSet{} + v.ptr = p + return v +} + +// TNpointSeqSetFromBaseTstzspanset is MEOS tnpointseqset_from_base_tstzspanset. +func TNpointSeqSetFromBaseTstzspanset(np *Npoint, ss *SpanSet, interp functions.Interpolation) (*Temporal, error) { + _r0, _err := functions.TnpointseqsetFromBaseTstzspanset(functions.NpointFromPointer(np.Pointer()), functions.SpanSetFromPointer(ss.Pointer()), interp) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tnumber.go b/types/tnumber.go new file mode 100644 index 0000000..01fef91 --- /dev/null +++ b/types/tnumber.go @@ -0,0 +1,188 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +// TNumber is temporal numbers; supports linear interpolation. + +type TNumber struct { + Temporal +} + +// TNumberFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TNumberFromPointer(p unsafe.Pointer) *TNumber { + if p == nil { + return nil + } + v := &TNumber{} + v.ptr = p + return v +} + +// ToSpan is MEOS tnumber_to_span. +func (x *TNumber) ToSpan() (*Span, error) { + _r0, _err := functions.TnumberToSpan(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// ToTbox is MEOS tnumber_to_tbox. +func (x *TNumber) ToTbox() (*TBox, error) { + _r0, _err := functions.TnumberToTBOX(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TBoxFromPointer(_r0.Pointer()), nil +} + +// Integral is MEOS tnumber_integral. +func (x *TNumber) Integral() (float64, error) { + _r0, _err := functions.TnumberIntegral(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Twavg is MEOS tnumber_twavg. +func (x *TNumber) Twavg() (float64, error) { + _r0, _err := functions.TnumberTwavg(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Valuespans is MEOS tnumber_valuespans. +func (x *TNumber) Valuespans() (*SpanSet, error) { + _r0, _err := functions.TnumberValuespans(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// AtSpan is MEOS tnumber_at_span. +func (x *TNumber) AtSpan(span *Span) (*Temporal, error) { + _r0, _err := functions.TnumberAtSpan(functions.TemporalFromPointer(x.Pointer()), functions.SpanFromPointer(span.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtSpanset is MEOS tnumber_at_spanset. +func (x *TNumber) AtSpanset(ss *SpanSet) (*Temporal, error) { + _r0, _err := functions.TnumberAtSpanset(functions.TemporalFromPointer(x.Pointer()), functions.SpanSetFromPointer(ss.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtTbox is MEOS tnumber_at_tbox. +func (x *TNumber) AtTbox(box *TBox) (*Temporal, error) { + _r0, _err := functions.TnumberAtTBOX(functions.TemporalFromPointer(x.Pointer()), functions.TBoxFromPointer(box.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusSpan is MEOS tnumber_minus_span. +func (x *TNumber) MinusSpan(span *Span) (*Temporal, error) { + _r0, _err := functions.TnumberMinusSpan(functions.TemporalFromPointer(x.Pointer()), functions.SpanFromPointer(span.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusSpanset is MEOS tnumber_minus_spanset. +func (x *TNumber) MinusSpanset(ss *SpanSet) (*Temporal, error) { + _r0, _err := functions.TnumberMinusSpanset(functions.TemporalFromPointer(x.Pointer()), functions.SpanSetFromPointer(ss.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusTbox is MEOS tnumber_minus_tbox. +func (x *TNumber) MinusTbox(box *TBox) (*Temporal, error) { + _r0, _err := functions.TnumberMinusTBOX(functions.TemporalFromPointer(x.Pointer()), functions.TBoxFromPointer(box.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// SplitEachNTboxes is MEOS tnumber_split_each_n_tboxes. +func (x *TNumber) SplitEachNTboxes(elem_count int, count unsafe.Pointer) (*TBox, error) { + _r0, _err := functions.TnumberSplitEachNTboxes(functions.TemporalFromPointer(x.Pointer()), elem_count, count) + if _err != nil { + return nil, _err + } + return TBoxFromPointer(_r0.Pointer()), nil +} + +// SplitNTboxes is MEOS tnumber_split_n_tboxes. +func (x *TNumber) SplitNTboxes(box_count int, count unsafe.Pointer) (*TBox, error) { + _r0, _err := functions.TnumberSplitNTboxes(functions.TemporalFromPointer(x.Pointer()), box_count, count) + if _err != nil { + return nil, _err + } + return TBoxFromPointer(_r0.Pointer()), nil +} + +// Tboxes is MEOS tnumber_tboxes. +func (x *TNumber) Tboxes(count unsafe.Pointer) (*TBox, error) { + _r0, _err := functions.TnumberTboxes(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return TBoxFromPointer(_r0.Pointer()), nil +} + +// Abs is MEOS tnumber_abs. +func (x *TNumber) Abs() (*Temporal, error) { + _r0, _err := functions.TnumberAbs(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Trend is MEOS tnumber_trend. +func (x *TNumber) Trend() (*Temporal, error) { + _r0, _err := functions.TnumberTrend(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AngularDifference is MEOS tnumber_angular_difference. +func (x *TNumber) AngularDifference() (*Temporal, error) { + _r0, _err := functions.TnumberAngularDifference(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// DeltaValue is MEOS tnumber_delta_value. +func (x *TNumber) DeltaValue() (*Temporal, error) { + _r0, _err := functions.TnumberDeltaValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tpcbox.go b/types/tpcbox.go new file mode 100644 index 0000000..6229934 --- /dev/null +++ b/types/tpcbox.go @@ -0,0 +1,324 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TPCBox struct { + Box +} + +// TPCBoxFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TPCBoxFromPointer(p unsafe.Pointer) *TPCBox { + if p == nil { + return nil + } + v := &TPCBox{} + v.ptr = p + return v +} + +// TPCBoxIn is MEOS tpcbox_in. +func TPCBoxIn(str string) (*TPCBox, error) { + _r0, _err := functions.TpcboxIn(str) + if _err != nil { + return nil, _err + } + return TPCBoxFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS tpcbox_out. +func (x *TPCBox) Out(maxdd int) (string, error) { + _r0, _err := functions.TpcboxOut(functions.TPCBoxFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// TPCBoxMake is MEOS tpcbox_make. +func TPCBoxMake(hasx bool, hasz bool, hast bool, geodetic bool, srid int32, pcid uint32, xmin float64, xmax float64, ymin float64, ymax float64, zmin float64, zmax float64, period *Span) (*TPCBox, error) { + _r0, _err := functions.TpcboxMake(hasx, hasz, hast, geodetic, srid, pcid, xmin, xmax, ymin, ymax, zmin, zmax, functions.SpanFromPointer(period.Pointer())) + if _err != nil { + return nil, _err + } + return TPCBoxFromPointer(_r0.Pointer()), nil +} + +// Copy is MEOS tpcbox_copy. +func (x *TPCBox) Copy() (*TPCBox, error) { + _r0, _err := functions.TpcboxCopy(functions.TPCBoxFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TPCBoxFromPointer(_r0.Pointer()), nil +} + +// Hasx is MEOS tpcbox_hasx. +func (x *TPCBox) Hasx() (bool, error) { + _r0, _err := functions.TpcboxHasx(functions.TPCBoxFromPointer(x.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Hasz is MEOS tpcbox_hasz. +func (x *TPCBox) Hasz() (bool, error) { + _r0, _err := functions.TpcboxHasz(functions.TPCBoxFromPointer(x.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Hast is MEOS tpcbox_hast. +func (x *TPCBox) Hast() (bool, error) { + _r0, _err := functions.TpcboxHast(functions.TPCBoxFromPointer(x.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Geodetic is MEOS tpcbox_geodetic. +func (x *TPCBox) Geodetic() (bool, error) { + _r0, _err := functions.TpcboxGeodetic(functions.TPCBoxFromPointer(x.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Xmin is MEOS tpcbox_xmin. +func (x *TPCBox) Xmin() (float64, bool, error) { + _found, _value, _err := functions.TpcboxXmin(functions.TPCBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// Xmax is MEOS tpcbox_xmax. +func (x *TPCBox) Xmax() (float64, bool, error) { + _found, _value, _err := functions.TpcboxXmax(functions.TPCBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// Ymin is MEOS tpcbox_ymin. +func (x *TPCBox) Ymin() (float64, bool, error) { + _found, _value, _err := functions.TpcboxYmin(functions.TPCBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// Ymax is MEOS tpcbox_ymax. +func (x *TPCBox) Ymax() (float64, bool, error) { + _found, _value, _err := functions.TpcboxYmax(functions.TPCBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// Zmin is MEOS tpcbox_zmin. +func (x *TPCBox) Zmin() (float64, bool, error) { + _found, _value, _err := functions.TpcboxZmin(functions.TPCBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// Zmax is MEOS tpcbox_zmax. +func (x *TPCBox) Zmax() (float64, bool, error) { + _found, _value, _err := functions.TpcboxZmax(functions.TPCBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// Tmin is MEOS tpcbox_tmin. +func (x *TPCBox) Tmin() (int64, bool, error) { + _found, _value, _err := functions.TpcboxTmin(functions.TPCBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// TminInc is MEOS tpcbox_tmin_inc. +func (x *TPCBox) TminInc() (bool, bool, error) { + _found, _value, _err := functions.TpcboxTminInc(functions.TPCBoxFromPointer(x.Pointer())) + if _err != nil { + return false, false, _err + } + if !_found { + return false, false, nil + } + return _value, true, nil +} + +// Tmax is MEOS tpcbox_tmax. +func (x *TPCBox) Tmax() (int64, bool, error) { + _found, _value, _err := functions.TpcboxTmax(functions.TPCBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// TmaxInc is MEOS tpcbox_tmax_inc. +func (x *TPCBox) TmaxInc() (bool, bool, error) { + _found, _value, _err := functions.TpcboxTmaxInc(functions.TPCBoxFromPointer(x.Pointer())) + if _err != nil { + return false, false, _err + } + if !_found { + return false, false, nil + } + return _value, true, nil +} + +// SRID is MEOS tpcbox_srid. +func (x *TPCBox) SRID() (int32, error) { + _r0, _err := functions.TpcboxSRID(functions.TPCBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Pcid is MEOS tpcbox_pcid. +func (x *TPCBox) Pcid() (uint32, error) { + _r0, _err := functions.TpcboxPcid(functions.TPCBoxFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ToStbox is MEOS tpcbox_to_stbox. +func (x *TPCBox) ToStbox() (*STBox, error) { + _r0, _err := functions.TpcboxToSTBOX(functions.TPCBoxFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// Round is MEOS tpcbox_round. +func (x *TPCBox) Round(maxdd int) (*TPCBox, error) { + _r0, _err := functions.TpcboxRound(functions.TPCBoxFromPointer(x.Pointer()), maxdd) + if _err != nil { + return nil, _err + } + return TPCBoxFromPointer(_r0.Pointer()), nil +} + +// SetSRID is MEOS tpcbox_set_srid. +func (x *TPCBox) SetSRID(srid int32) (*TPCBox, error) { + _r0, _err := functions.TpcboxSetSRID(functions.TPCBoxFromPointer(x.Pointer()), srid) + if _err != nil { + return nil, _err + } + return TPCBoxFromPointer(_r0.Pointer()), nil +} + +// Cmp is MEOS tpcbox_cmp. +func (x *TPCBox) Cmp(box2 *TPCBox) (int, error) { + _r0, _err := functions.TpcboxCmp(functions.TPCBoxFromPointer(x.Pointer()), functions.TPCBoxFromPointer(box2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Eq is MEOS tpcbox_eq. +func (x *TPCBox) Eq(box2 *TPCBox) (bool, error) { + _r0, _err := functions.TpcboxEq(functions.TPCBoxFromPointer(x.Pointer()), functions.TPCBoxFromPointer(box2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Ne is MEOS tpcbox_ne. +func (x *TPCBox) Ne(box2 *TPCBox) (bool, error) { + _r0, _err := functions.TpcboxNe(functions.TPCBoxFromPointer(x.Pointer()), functions.TPCBoxFromPointer(box2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Lt is MEOS tpcbox_lt. +func (x *TPCBox) Lt(box2 *TPCBox) (bool, error) { + _r0, _err := functions.TpcboxLt(functions.TPCBoxFromPointer(x.Pointer()), functions.TPCBoxFromPointer(box2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Le is MEOS tpcbox_le. +func (x *TPCBox) Le(box2 *TPCBox) (bool, error) { + _r0, _err := functions.TpcboxLe(functions.TPCBoxFromPointer(x.Pointer()), functions.TPCBoxFromPointer(box2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Gt is MEOS tpcbox_gt. +func (x *TPCBox) Gt(box2 *TPCBox) (bool, error) { + _r0, _err := functions.TpcboxGt(functions.TPCBoxFromPointer(x.Pointer()), functions.TPCBoxFromPointer(box2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Ge is MEOS tpcbox_ge. +func (x *TPCBox) Ge(box2 *TPCBox) (bool, error) { + _r0, _err := functions.TpcboxGe(functions.TPCBoxFromPointer(x.Pointer()), functions.TPCBoxFromPointer(box2.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} diff --git a/types/tpoint.go b/types/tpoint.go new file mode 100644 index 0000000..087c21f --- /dev/null +++ b/types/tpoint.go @@ -0,0 +1,221 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +// TPoint is temporal points. API-level intermediate (C predicate tpoint_type + the tpoint_* method family); NOT drawn in the manual Figure 7.1 (a conceptual diagram) but required so the tpoint_* methods bind to a class — see correction OM-M6. + +type TPoint struct { + TGeo +} + +// TPointFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TPointFromPointer(p unsafe.Pointer) *TPoint { + if p == nil { + return nil + } + v := &TPoint{} + v.ptr = p + return v +} + +// TPointFromBaseTemp is MEOS tpoint_from_base_temp. +func TPointFromBaseTemp(gs *TRGeometrySeqSet, temp *Temporal) (*Temporal, error) { + _r0, _err := functions.TpointFromBaseTemp(functions.GeomFromPointer(gs.Pointer()), functions.TemporalFromPointer(temp.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TfloatToGeomeas is MEOS tpoint_tfloat_to_geomeas. +func (x *TPoint) TfloatToGeomeas(measure *Temporal, segmentize bool) (*TRGeometrySeqSet, bool, error) { + _found, _value, _err := functions.TpointTfloatToGeomeas(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(measure.Pointer()), segmentize) + if _err != nil { + return nil, false, _err + } + if !_found { + return nil, false, nil + } + return TRGeometrySeqSetFromPointer(_value.Pointer()), true, nil +} + +// AngularDifference is MEOS tpoint_angular_difference. +func (x *TPoint) AngularDifference() (*Temporal, error) { + _r0, _err := functions.TpointAngularDifference(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Azimuth is MEOS tpoint_azimuth. +func (x *TPoint) Azimuth() (*Temporal, error) { + _r0, _err := functions.TpointAzimuth(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// CumulativeLength is MEOS tpoint_cumulative_length. +func (x *TPoint) CumulativeLength() (*Temporal, error) { + _r0, _err := functions.TpointCumulativeLength(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Direction is MEOS tpoint_direction. +func (x *TPoint) Direction() (float64, bool, error) { + _found, _value, _err := functions.TpointDirection(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// GetX is MEOS tpoint_get_x. +func (x *TPoint) GetX() (*Temporal, error) { + _r0, _err := functions.TpointGetX(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// GetY is MEOS tpoint_get_y. +func (x *TPoint) GetY() (*Temporal, error) { + _r0, _err := functions.TpointGetY(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// GetZ is MEOS tpoint_get_z. +func (x *TPoint) GetZ() (*Temporal, error) { + _r0, _err := functions.TpointGetZ(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// IsSimple is MEOS tpoint_is_simple. +func (x *TPoint) IsSimple() (bool, error) { + _r0, _err := functions.TpointIsSimple(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return false, _err + } + return _r0, nil +} + +// Length is MEOS tpoint_length. +func (x *TPoint) Length() (float64, error) { + _r0, _err := functions.TpointLength(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Speed is MEOS tpoint_speed. +func (x *TPoint) Speed() (*Temporal, error) { + _r0, _err := functions.TpointSpeed(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Trajectory is MEOS tpoint_trajectory. +func (x *TPoint) Trajectory(unary_union bool) (*TRGeometrySeqSet, error) { + _r0, _err := functions.TpointTrajectory(functions.TemporalFromPointer(x.Pointer()), unary_union) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// Twcentroid is MEOS tpoint_twcentroid. +func (x *TPoint) Twcentroid() (*TRGeometrySeqSet, error) { + _r0, _err := functions.TpointTwcentroid(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// MakeSimple is MEOS tpoint_make_simple. +func (x *TPoint) MakeSimple(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TpointMakeSimple(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// AtElevation is MEOS tpoint_at_elevation. +func (x *TPoint) AtElevation(s *Span) (*Temporal, error) { + _r0, _err := functions.TpointAtElevation(functions.TemporalFromPointer(x.Pointer()), functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtGeom is MEOS tpoint_at_geom. +func (x *TPoint) AtGeom(gs *TRGeometrySeqSet) (*Temporal, error) { + _r0, _err := functions.TpointAtGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtValue is MEOS tpoint_at_value. +func (x *TPoint) AtValue(gs *TRGeometrySeqSet) (*Temporal, error) { + _r0, _err := functions.TpointAtValue(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusElevation is MEOS tpoint_minus_elevation. +func (x *TPoint) MinusElevation(s *Span) (*Temporal, error) { + _r0, _err := functions.TpointMinusElevation(functions.TemporalFromPointer(x.Pointer()), functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusGeom is MEOS tpoint_minus_geom. +func (x *TPoint) MinusGeom(gs *TRGeometrySeqSet) (*Temporal, error) { + _r0, _err := functions.TpointMinusGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusValue is MEOS tpoint_minus_value. +func (x *TPoint) MinusValue(gs *TRGeometrySeqSet) (*Temporal, error) { + _r0, _err := functions.TpointMinusValue(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tpose.go b/types/tpose.go new file mode 100644 index 0000000..b07c651 --- /dev/null +++ b/types/tpose.go @@ -0,0 +1,327 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TPose struct { + TSpatial +} + +// TPoseFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TPoseFromPointer(p unsafe.Pointer) *TPose { + if p == nil { + return nil + } + v := &TPose{} + v.ptr = p + return v +} + +// TPoseFromGeopose is MEOS tpose_from_geopose. +func TPoseFromGeopose(json string) (*Temporal, error) { + _r0, _err := functions.TposeFromGeopose(json) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AsGeopose is MEOS tpose_as_geopose. +func (x *TPose) AsGeopose(conformance int, precision int) (string, error) { + _r0, _err := functions.TposeAsGeopose(functions.TemporalFromPointer(x.Pointer()), conformance, precision) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// AsGeoposeStreamElement is MEOS tpose_as_geopose_stream_element. +func (x *TPose) AsGeoposeStreamElement(inst *Temporal, precision int) (string, error) { + _r0, _err := functions.TposeAsGeoposeStreamElement(functions.TemporalFromPointer(x.Pointer()), functions.TInstantFromPointer(inst.Pointer()), precision) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// AsGeoposeStream is MEOS tpose_as_geopose_stream. +func (x *TPose) AsGeoposeStream(precision int) (string, error) { + _r0, _err := functions.TposeAsGeoposeStream(functions.TemporalFromPointer(x.Pointer()), precision) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// ApplyGeo is MEOS tpose_apply_geo. +func (x *TPose) ApplyGeo(body *TRGeometrySeqSet) (*Temporal, error) { + _r0, _err := functions.TposeApplyGeo(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(body.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ComposePose is MEOS tpose_compose_pose. +func (x *TPose) ComposePose(frame *Pose) (*Temporal, error) { + _r0, _err := functions.TposeComposePose(functions.TemporalFromPointer(x.Pointer()), functions.PoseFromPointer(frame.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ComposeTpose is MEOS tpose_compose_tpose. +func (x *TPose) ComposeTpose(frame *Temporal) (*Temporal, error) { + _r0, _err := functions.TposeComposeTpose(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(frame.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Inverse is MEOS tpose_inverse. +func (x *TPose) Inverse() (*Temporal, error) { + _r0, _err := functions.TposeInverse(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TPoseFromMFJSON is MEOS tpose_from_mfjson. +func TPoseFromMFJSON(str string) (*Temporal, error) { + _r0, _err := functions.TposeFromMFJSON(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TPoseIn is MEOS tpose_in. +func TPoseIn(str string) (*Temporal, error) { + _r0, _err := functions.TposeIn(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TPoseFromBaseTemp is MEOS tpose_from_base_temp. +func TPoseFromBaseTemp(pose *Pose, temp *Temporal) (*Temporal, error) { + _r0, _err := functions.TposeFromBaseTemp(functions.PoseFromPointer(pose.Pointer()), functions.TemporalFromPointer(temp.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Make is MEOS tpose_make. +func (x *TPose) Make(ttheta *Temporal) (*Temporal, error) { + _r0, _err := functions.TposeMake(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(ttheta.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTpoint is MEOS tpose_to_tpoint. +func (x *TPose) ToTpoint() (*Temporal, error) { + _r0, _err := functions.TposeToTpoint(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS tpose_end_value. +func (x *TPose) EndValue() (*Pose, error) { + _r0, _err := functions.TposeEndValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// Points is MEOS tpose_points. +func (x *TPose) Points() (*Set, error) { + _r0, _err := functions.TposePoints(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Yaw is MEOS tpose_yaw. +func (x *TPose) Yaw() (*Temporal, error) { + _r0, _err := functions.TposeYaw(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Pitch is MEOS tpose_pitch. +func (x *TPose) Pitch() (*Temporal, error) { + _r0, _err := functions.TposePitch(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Roll is MEOS tpose_roll. +func (x *TPose) Roll() (*Temporal, error) { + _r0, _err := functions.TposeRoll(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Speed is MEOS tpose_speed. +func (x *TPose) Speed() (*Temporal, error) { + _r0, _err := functions.TposeSpeed(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AngularSpeed is MEOS tpose_angular_speed. +func (x *TPose) AngularSpeed() (*Temporal, error) { + _r0, _err := functions.TposeAngularSpeed(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// StartValue is MEOS tpose_start_value. +func (x *TPose) StartValue() (*Pose, error) { + _r0, _err := functions.TposeStartValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return PoseFromPointer(_r0.Pointer()), nil +} + +// Trajectory is MEOS tpose_trajectory. +func (x *TPose) Trajectory() (*TRGeometrySeqSet, error) { + _r0, _err := functions.TposeTrajectory(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// ValueAtTimestamptz is MEOS tpose_value_at_timestamptz. +func (x *TPose) ValueAtTimestamptz(t int64, strict bool) (*Pose, bool, error) { + _found, _value, _err := functions.TposeValueAtTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, strict) + if _err != nil { + return nil, false, _err + } + if !_found { + return nil, false, nil + } + return PoseFromPointer(_value.Pointer()), true, nil +} + +// ValueN is MEOS tpose_value_n. +func (x *TPose) ValueN(n int) (*Pose, bool, error) { + _found, _value, _err := functions.TposeValueN(functions.TemporalFromPointer(x.Pointer()), n) + if _err != nil { + return nil, false, _err + } + if !_found { + return nil, false, nil + } + return PoseFromPointer(_value.Pointer()), true, nil +} + +// Values is MEOS tpose_values. +func (x *TPose) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TposeValues(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// AtElevation is MEOS tpose_at_elevation. +func (x *TPose) AtElevation(s *Span) (*Temporal, error) { + _r0, _err := functions.TposeAtElevation(functions.TemporalFromPointer(x.Pointer()), functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtGeom is MEOS tpose_at_geom. +func (x *TPose) AtGeom(gs *TRGeometrySeqSet) (*Temporal, error) { + _r0, _err := functions.TposeAtGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtStbox is MEOS tpose_at_stbox. +func (x *TPose) AtStbox(box *STBox, border_inc bool) (*Temporal, error) { + _r0, _err := functions.TposeAtSTBOX(functions.TemporalFromPointer(x.Pointer()), functions.STBoxFromPointer(box.Pointer()), border_inc) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtPose is MEOS tpose_at_pose. +func (x *TPose) AtPose(pose *Pose) (*Temporal, error) { + _r0, _err := functions.TposeAtPose(functions.TemporalFromPointer(x.Pointer()), functions.PoseFromPointer(pose.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusElevation is MEOS tpose_minus_elevation. +func (x *TPose) MinusElevation(s *Span) (*Temporal, error) { + _r0, _err := functions.TposeMinusElevation(functions.TemporalFromPointer(x.Pointer()), functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusGeom is MEOS tpose_minus_geom. +func (x *TPose) MinusGeom(gs *TRGeometrySeqSet) (*Temporal, error) { + _r0, _err := functions.TposeMinusGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusPose is MEOS tpose_minus_pose. +func (x *TPose) MinusPose(pose *Pose) (*Temporal, error) { + _r0, _err := functions.TposeMinusPose(functions.TemporalFromPointer(x.Pointer()), functions.PoseFromPointer(pose.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusStbox is MEOS tpose_minus_stbox. +func (x *TPose) MinusStbox(box *STBox, border_inc bool) (*Temporal, error) { + _r0, _err := functions.TposeMinusSTBOX(functions.TemporalFromPointer(x.Pointer()), functions.STBoxFromPointer(box.Pointer()), border_inc) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tposeinst.go b/types/tposeinst.go new file mode 100644 index 0000000..ec3675a --- /dev/null +++ b/types/tposeinst.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TPoseInst struct { + handle +} + +// TPoseInstFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TPoseInstFromPointer(p unsafe.Pointer) *TPoseInst { + if p == nil { + return nil + } + v := &TPoseInst{} + v.ptr = p + return v +} + +// TPoseInstMake is MEOS tposeinst_make. +func TPoseInstMake(pose *Pose, t int64) (*Temporal, error) { + _r0, _err := functions.TposeinstMake(functions.PoseFromPointer(pose.Pointer()), t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tposeseq.go b/types/tposeseq.go new file mode 100644 index 0000000..257ad2b --- /dev/null +++ b/types/tposeseq.go @@ -0,0 +1,42 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TPoseSeq struct { + handle +} + +// TPoseSeqFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TPoseSeqFromPointer(p unsafe.Pointer) *TPoseSeq { + if p == nil { + return nil + } + v := &TPoseSeq{} + v.ptr = p + return v +} + +// TPoseSeqFromBaseTstzset is MEOS tposeseq_from_base_tstzset. +func TPoseSeqFromBaseTstzset(pose *Pose, s *Set) (*Temporal, error) { + _r0, _err := functions.TposeseqFromBaseTstzset(functions.PoseFromPointer(pose.Pointer()), functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TPoseSeqFromBaseTstzspan is MEOS tposeseq_from_base_tstzspan. +func TPoseSeqFromBaseTstzspan(pose *Pose, s *Span, interp functions.Interpolation) (*Temporal, error) { + _r0, _err := functions.TposeseqFromBaseTstzspan(functions.PoseFromPointer(pose.Pointer()), functions.SpanFromPointer(s.Pointer()), interp) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tposeseqset.go b/types/tposeseqset.go new file mode 100644 index 0000000..0884325 --- /dev/null +++ b/types/tposeseqset.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TPoseSeqSet struct { + handle +} + +// TPoseSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TPoseSeqSetFromPointer(p unsafe.Pointer) *TPoseSeqSet { + if p == nil { + return nil + } + v := &TPoseSeqSet{} + v.ptr = p + return v +} + +// TPoseSeqSetFromBaseTstzspanset is MEOS tposeseqset_from_base_tstzspanset. +func TPoseSeqSetFromBaseTstzspanset(pose *Pose, ss *SpanSet, interp functions.Interpolation) (*Temporal, error) { + _r0, _err := functions.TposeseqsetFromBaseTstzspanset(functions.PoseFromPointer(pose.Pointer()), functions.SpanSetFromPointer(ss.Pointer()), interp) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/trgeometry.go b/types/trgeometry.go new file mode 100644 index 0000000..0ac0392 --- /dev/null +++ b/types/trgeometry.go @@ -0,0 +1,684 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TRGeometry struct { + TSpatial +} + +// TRGeometryFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TRGeometryFromPointer(p unsafe.Pointer) *TRGeometry { + if p == nil { + return nil + } + v := &TRGeometry{} + v.ptr = p + return v +} + +// TRGeometryIn is MEOS trgeometry_in. +func TRGeometryIn(str string) (*Temporal, error) { + _r0, _err := functions.TrgeometryIn(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TRGeometryFromMFJSON is MEOS trgeometry_from_mfjson. +func TRGeometryFromMFJSON(mfjson string) (*Temporal, error) { + _r0, _err := functions.TrgeometryFromMFJSON(mfjson) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS trgeometry_out. +func (x *TRGeometry) Out() (string, error) { + _r0, _err := functions.TrgeometryOut(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// AsText is MEOS trgeometry_as_text. +func (x *TRGeometry) AsText(maxdd int) (string, error) { + _r0, _err := functions.TrgeometryAsText(functions.TemporalFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// AsEWKT is MEOS trgeometry_as_ewkt. +func (x *TRGeometry) AsEWKT(maxdd int) (string, error) { + _r0, _err := functions.TrgeometryAsEWKT(functions.TemporalFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// ToTpose is MEOS trgeometry_to_tpose. +func (x *TRGeometry) ToTpose() (*Temporal, error) { + _r0, _err := functions.TrgeometryToTpose(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTgeompoint is MEOS trgeometry_to_tgeompoint. +func (x *TRGeometry) ToTgeompoint() (*Temporal, error) { + _r0, _err := functions.TrgeometryToTgeompoint(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTgeometry is MEOS trgeometry_to_tgeometry. +func (x *TRGeometry) ToTgeometry() (*Temporal, error) { + _r0, _err := functions.TrgeometryToTgeometry(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// EndInstant is MEOS trgeometry_end_instant. +func (x *TRGeometry) EndInstant() (*Temporal, error) { + _r0, _err := functions.TrgeometryEndInstant(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// EndSequence is MEOS trgeometry_end_sequence. +func (x *TRGeometry) EndSequence() (*Temporal, error) { + _r0, _err := functions.TrgeometryEndSequence(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS trgeometry_end_value. +func (x *TRGeometry) EndValue() (*TRGeometrySeqSet, error) { + _r0, _err := functions.TrgeometryEndValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// Geom is MEOS trgeometry_geom. +func (x *TRGeometry) Geom() (*TRGeometrySeqSet, error) { + _r0, _err := functions.TrgeometryGeom(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// InstantN is MEOS trgeometry_instant_n. +func (x *TRGeometry) InstantN(n int) (*Temporal, error) { + _r0, _err := functions.TrgeometryInstantN(functions.TemporalFromPointer(x.Pointer()), n) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Instants is MEOS trgeometry_instants. +func (x *TRGeometry) Instants(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TrgeometryInstants(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Points is MEOS trgeometry_points. +func (x *TRGeometry) Points() (*Set, error) { + _r0, _err := functions.TrgeometryPoints(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Yaw is MEOS trgeometry_yaw. +func (x *TRGeometry) Yaw() (*Temporal, error) { + _r0, _err := functions.TrgeometryYaw(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Pitch is MEOS trgeometry_pitch. +func (x *TRGeometry) Pitch() (*Temporal, error) { + _r0, _err := functions.TrgeometryPitch(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Roll is MEOS trgeometry_roll. +func (x *TRGeometry) Roll() (*Temporal, error) { + _r0, _err := functions.TrgeometryRoll(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Segments is MEOS trgeometry_segments. +func (x *TRGeometry) Segments(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TrgeometrySegments(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// SequenceN is MEOS trgeometry_sequence_n. +func (x *TRGeometry) SequenceN(i int) (*Temporal, error) { + _r0, _err := functions.TrgeometrySequenceN(functions.TemporalFromPointer(x.Pointer()), i) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Sequences is MEOS trgeometry_sequences. +func (x *TRGeometry) Sequences(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TrgeometrySequences(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// StartInstant is MEOS trgeometry_start_instant. +func (x *TRGeometry) StartInstant() (*Temporal, error) { + _r0, _err := functions.TrgeometryStartInstant(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// StartSequence is MEOS trgeometry_start_sequence. +func (x *TRGeometry) StartSequence() (*Temporal, error) { + _r0, _err := functions.TrgeometryStartSequence(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// StartValue is MEOS trgeometry_start_value. +func (x *TRGeometry) StartValue() (*TRGeometrySeqSet, error) { + _r0, _err := functions.TrgeometryStartValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// ValueN is MEOS trgeometry_value_n. +func (x *TRGeometry) ValueN(n int) (*TRGeometrySeqSet, bool, error) { + _found, _value, _err := functions.TrgeometryValueN(functions.TemporalFromPointer(x.Pointer()), n) + if _err != nil { + return nil, false, _err + } + if !_found { + return nil, false, nil + } + return TRGeometrySeqSetFromPointer(_value.Pointer()), true, nil +} + +// TraversedArea is MEOS trgeometry_traversed_area. +func (x *TRGeometry) TraversedArea(unary_union bool) (*TRGeometrySeqSet, error) { + _r0, _err := functions.TrgeometryTraversedArea(functions.TemporalFromPointer(x.Pointer()), unary_union) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// Centroid is MEOS trgeometry_centroid. +func (x *TRGeometry) Centroid() (*Temporal, error) { + _r0, _err := functions.TrgeometryCentroid(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ConvexHull is MEOS trgeometry_convex_hull. +func (x *TRGeometry) ConvexHull() (*TRGeometrySeqSet, error) { + _r0, _err := functions.TrgeometryConvexHull(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// BodyPointTrajectory is MEOS trgeometry_body_point_trajectory. +func (x *TRGeometry) BodyPointTrajectory(gs *TRGeometrySeqSet) (*Temporal, error) { + _r0, _err := functions.TrgeometryBodyPointTrajectory(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// SpaceBoxes is MEOS trgeometry_space_boxes. +func (x *TRGeometry) SpaceBoxes(xsize float64, ysize float64, zsize float64, sorigin *TRGeometrySeqSet, bitmatrix bool, border_inc bool, count unsafe.Pointer) (*STBox, error) { + _r0, _err := functions.TrgeometrySpaceBoxes(functions.TemporalFromPointer(x.Pointer()), xsize, ysize, zsize, functions.GeomFromPointer(sorigin.Pointer()), bitmatrix, border_inc, count) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// Stboxes is MEOS trgeometry_stboxes. +func (x *TRGeometry) Stboxes(count unsafe.Pointer) (*STBox, error) { + _r0, _err := functions.TrgeometryStboxes(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// SplitNStboxes is MEOS trgeometry_split_n_stboxes. +func (x *TRGeometry) SplitNStboxes(box_count int, count unsafe.Pointer) (*STBox, error) { + _r0, _err := functions.TrgeometrySplitNStboxes(functions.TemporalFromPointer(x.Pointer()), box_count, count) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// SplitEachNStboxes is MEOS trgeometry_split_each_n_stboxes. +func (x *TRGeometry) SplitEachNStboxes(elem_count int, count unsafe.Pointer) (*STBox, error) { + _r0, _err := functions.TrgeometrySplitEachNStboxes(functions.TemporalFromPointer(x.Pointer()), elem_count, count) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// HausdorffDistance is MEOS trgeometry_hausdorff_distance. +func (x *TRGeometry) HausdorffDistance(temp2 *Temporal) (float64, error) { + _r0, _err := functions.TrgeometryHausdorffDistance(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// FrechetDistance is MEOS trgeometry_frechet_distance. +func (x *TRGeometry) FrechetDistance(temp2 *Temporal) (float64, error) { + _r0, _err := functions.TrgeometryFrechetDistance(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// DyntimewarpDistance is MEOS trgeometry_dyntimewarp_distance. +func (x *TRGeometry) DyntimewarpDistance(temp2 *Temporal) (float64, error) { + _r0, _err := functions.TrgeometryDyntimewarpDistance(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Length is MEOS trgeometry_length. +func (x *TRGeometry) Length() (float64, error) { + _r0, _err := functions.TrgeometryLength(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// CumulativeLength is MEOS trgeometry_cumulative_length. +func (x *TRGeometry) CumulativeLength() (*Temporal, error) { + _r0, _err := functions.TrgeometryCumulativeLength(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AngularSpeed is MEOS trgeometry_angular_speed. +func (x *TRGeometry) AngularSpeed() (*Temporal, error) { + _r0, _err := functions.TrgeometryAngularSpeed(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Speed is MEOS trgeometry_speed. +func (x *TRGeometry) Speed() (*Temporal, error) { + _r0, _err := functions.TrgeometrySpeed(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Twcentroid is MEOS trgeometry_twcentroid. +func (x *TRGeometry) Twcentroid() (*TRGeometrySeqSet, error) { + _r0, _err := functions.TrgeometryTwcentroid(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// AppendTsequence is MEOS trgeometry_append_tsequence. +func (x *TRGeometry) AppendTsequence(seq *Temporal, expand bool) (*Temporal, error) { + _r0, _err := functions.TrgeometryAppendTsequence(functions.TemporalFromPointer(x.Pointer()), functions.TSequenceFromPointer(seq.Pointer()), expand) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// DeleteTimestamptz is MEOS trgeometry_delete_timestamptz. +func (x *TRGeometry) DeleteTimestamptz(t int64, connect bool) (*Temporal, error) { + _r0, _err := functions.TrgeometryDeleteTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, connect) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// DeleteTstzset is MEOS trgeometry_delete_tstzset. +func (x *TRGeometry) DeleteTstzset(s *Set, connect bool) (*Temporal, error) { + _r0, _err := functions.TrgeometryDeleteTstzset(functions.TemporalFromPointer(x.Pointer()), functions.SetFromPointer(s.Pointer()), connect) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// DeleteTstzspan is MEOS trgeometry_delete_tstzspan. +func (x *TRGeometry) DeleteTstzspan(s *Span, connect bool) (*Temporal, error) { + _r0, _err := functions.TrgeometryDeleteTstzspan(functions.TemporalFromPointer(x.Pointer()), functions.SpanFromPointer(s.Pointer()), connect) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// DeleteTstzspanset is MEOS trgeometry_delete_tstzspanset. +func (x *TRGeometry) DeleteTstzspanset(ss *SpanSet, connect bool) (*Temporal, error) { + _r0, _err := functions.TrgeometryDeleteTstzspanset(functions.TemporalFromPointer(x.Pointer()), functions.SpanSetFromPointer(ss.Pointer()), connect) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Merge is MEOS trgeometry_merge. +func (x *TRGeometry) Merge(temp2 *Temporal) (*Temporal, error) { + _r0, _err := functions.TrgeometryMerge(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TRGeometryMergeArray is MEOS trgeometry_merge_array. +func TRGeometryMergeArray(temparr unsafe.Pointer, count int) (*Temporal, error) { + _r0, _err := functions.TrgeometryMergeArray(temparr, count) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Round is MEOS trgeometry_round. +func (x *TRGeometry) Round(maxdd int) (*Temporal, error) { + _r0, _err := functions.TrgeometryRound(functions.TemporalFromPointer(x.Pointer()), maxdd) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// SetInterp is MEOS trgeometry_set_interp. +func (x *TRGeometry) SetInterp(interp functions.Interpolation) (*Temporal, error) { + _r0, _err := functions.TrgeometrySetInterp(functions.TemporalFromPointer(x.Pointer()), interp) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AsTinstant is MEOS trgeometry_as_tinstant. +func (x *TRGeometry) AsTinstant() (*Temporal, error) { + _r0, _err := functions.TrgeometryAsTinstant(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AsTsequence is MEOS trgeometry_as_tsequence. +func (x *TRGeometry) AsTsequence(interp_str string) (*Temporal, error) { + _r0, _err := functions.TrgeometryAsTsequence(functions.TemporalFromPointer(x.Pointer()), interp_str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AsTsequenceset is MEOS trgeometry_as_tsequenceset. +func (x *TRGeometry) AsTsequenceset(interp_str string) (*Temporal, error) { + _r0, _err := functions.TrgeometryAsTsequenceset(functions.TemporalFromPointer(x.Pointer()), interp_str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AfterTimestamptz is MEOS trgeometry_after_timestamptz. +func (x *TRGeometry) AfterTimestamptz(t int64, strict bool) (*Temporal, error) { + _r0, _err := functions.TrgeometryAfterTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, strict) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// BeforeTimestamptz is MEOS trgeometry_before_timestamptz. +func (x *TRGeometry) BeforeTimestamptz(t int64, strict bool) (*Temporal, error) { + _r0, _err := functions.TrgeometryBeforeTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, strict) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtGeom is MEOS trgeometry_at_geom. +func (x *TRGeometry) AtGeom(gs *TRGeometrySeqSet) (*Temporal, error) { + _r0, _err := functions.TrgeometryAtGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusGeom is MEOS trgeometry_minus_geom. +func (x *TRGeometry) MinusGeom(gs *TRGeometrySeqSet) (*Temporal, error) { + _r0, _err := functions.TrgeometryMinusGeom(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(gs.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtStbox is MEOS trgeometry_at_stbox. +func (x *TRGeometry) AtStbox(box *STBox, border_inc bool) (*Temporal, error) { + _r0, _err := functions.TrgeometryAtSTBOX(functions.TemporalFromPointer(x.Pointer()), functions.STBoxFromPointer(box.Pointer()), border_inc) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusStbox is MEOS trgeometry_minus_stbox. +func (x *TRGeometry) MinusStbox(box *STBox, border_inc bool) (*Temporal, error) { + _r0, _err := functions.TrgeometryMinusSTBOX(functions.TemporalFromPointer(x.Pointer()), functions.STBoxFromPointer(box.Pointer()), border_inc) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtValue is MEOS trgeometry_at_value. +func (x *TRGeometry) AtValue(pose *Pose) (*Temporal, error) { + _r0, _err := functions.TrgeometryAtValue(functions.TemporalFromPointer(x.Pointer()), functions.PoseFromPointer(pose.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusValue is MEOS trgeometry_minus_value. +func (x *TRGeometry) MinusValue(pose *Pose) (*Temporal, error) { + _r0, _err := functions.TrgeometryMinusValue(functions.TemporalFromPointer(x.Pointer()), functions.PoseFromPointer(pose.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtValues is MEOS trgeometry_at_values. +func (x *TRGeometry) AtValues(s *Set) (*Temporal, error) { + _r0, _err := functions.TrgeometryAtValues(functions.TemporalFromPointer(x.Pointer()), functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusValues is MEOS trgeometry_minus_values. +func (x *TRGeometry) MinusValues(s *Set) (*Temporal, error) { + _r0, _err := functions.TrgeometryMinusValues(functions.TemporalFromPointer(x.Pointer()), functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtTimestamptz is MEOS trgeometry_at_timestamptz. +func (x *TRGeometry) AtTimestamptz(t int64) (*Temporal, error) { + _r0, _err := functions.TrgeometryAtTimestamptz(functions.TemporalFromPointer(x.Pointer()), t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusTimestamptz is MEOS trgeometry_minus_timestamptz. +func (x *TRGeometry) MinusTimestamptz(t int64) (*Temporal, error) { + _r0, _err := functions.TrgeometryMinusTimestamptz(functions.TemporalFromPointer(x.Pointer()), t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtTstzset is MEOS trgeometry_at_tstzset. +func (x *TRGeometry) AtTstzset(s *Set) (*Temporal, error) { + _r0, _err := functions.TrgeometryAtTstzset(functions.TemporalFromPointer(x.Pointer()), functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusTstzset is MEOS trgeometry_minus_tstzset. +func (x *TRGeometry) MinusTstzset(s *Set) (*Temporal, error) { + _r0, _err := functions.TrgeometryMinusTstzset(functions.TemporalFromPointer(x.Pointer()), functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtTstzspan is MEOS trgeometry_at_tstzspan. +func (x *TRGeometry) AtTstzspan(s *Span) (*Temporal, error) { + _r0, _err := functions.TrgeometryAtTstzspan(functions.TemporalFromPointer(x.Pointer()), functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusTstzspan is MEOS trgeometry_minus_tstzspan. +func (x *TRGeometry) MinusTstzspan(s *Span) (*Temporal, error) { + _r0, _err := functions.TrgeometryMinusTstzspan(functions.TemporalFromPointer(x.Pointer()), functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtTstzspanset is MEOS trgeometry_at_tstzspanset. +func (x *TRGeometry) AtTstzspanset(ss *SpanSet) (*Temporal, error) { + _r0, _err := functions.TrgeometryAtTstzspanset(functions.TemporalFromPointer(x.Pointer()), functions.SpanSetFromPointer(ss.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusTstzspanset is MEOS trgeometry_minus_tstzspanset. +func (x *TRGeometry) MinusTstzspanset(ss *SpanSet) (*Temporal, error) { + _r0, _err := functions.TrgeometryMinusTstzspanset(functions.TemporalFromPointer(x.Pointer()), functions.SpanSetFromPointer(ss.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtElevation is MEOS trgeometry_at_elevation. +func (x *TRGeometry) AtElevation(s *Span) (*Temporal, error) { + _r0, _err := functions.TrgeometryAtElevation(functions.TemporalFromPointer(x.Pointer()), functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusElevation is MEOS trgeometry_minus_elevation. +func (x *TRGeometry) MinusElevation(s *Span) (*Temporal, error) { + _r0, _err := functions.TrgeometryMinusElevation(functions.TemporalFromPointer(x.Pointer()), functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/trgeometryinst.go b/types/trgeometryinst.go new file mode 100644 index 0000000..3af8965 --- /dev/null +++ b/types/trgeometryinst.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TRGeometryInst struct { + handle +} + +// TRGeometryInstFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TRGeometryInstFromPointer(p unsafe.Pointer) *TRGeometryInst { + if p == nil { + return nil + } + v := &TRGeometryInst{} + v.ptr = p + return v +} + +// TRGeometryInstMake is MEOS trgeometryinst_make. +func TRGeometryInstMake(geom *TRGeometrySeqSet, pose *Pose, t int64) (*Temporal, error) { + _r0, _err := functions.TrgeometryinstMake(functions.GeomFromPointer(geom.Pointer()), functions.PoseFromPointer(pose.Pointer()), t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/trgeometryseq.go b/types/trgeometryseq.go new file mode 100644 index 0000000..5ad2c22 --- /dev/null +++ b/types/trgeometryseq.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TRGeometrySeq struct { + handle +} + +// TRGeometrySeqFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TRGeometrySeqFromPointer(p unsafe.Pointer) *TRGeometrySeq { + if p == nil { + return nil + } + v := &TRGeometrySeq{} + v.ptr = p + return v +} + +// TRGeometrySeqMake is MEOS trgeometryseq_make. +func TRGeometrySeqMake(geom *TRGeometrySeqSet, instants unsafe.Pointer, count int, lower_inc bool, upper_inc bool, interp functions.Interpolation, normalize bool) (*Temporal, error) { + _r0, _err := functions.TrgeometryseqMake(functions.GeomFromPointer(geom.Pointer()), instants, count, lower_inc, upper_inc, interp, normalize) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/trgeometryseqset.go b/types/trgeometryseqset.go new file mode 100644 index 0000000..62a8870 --- /dev/null +++ b/types/trgeometryseqset.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TRGeometrySeqSet struct { + handle +} + +// TRGeometrySeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TRGeometrySeqSetFromPointer(p unsafe.Pointer) *TRGeometrySeqSet { + if p == nil { + return nil + } + v := &TRGeometrySeqSet{} + v.ptr = p + return v +} + +// Make is MEOS trgeometryseqset_make. +func (x *TRGeometrySeqSet) Make(sequences unsafe.Pointer, count int, normalize bool) (*Temporal, error) { + _r0, _err := functions.TrgeometryseqsetMake(functions.GeomFromPointer(x.Pointer()), sequences, count, normalize) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tsequence.go b/types/tsequence.go new file mode 100644 index 0000000..06475b3 --- /dev/null +++ b/types/tsequence.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TSequence struct { + Temporal +} + +// TSequenceFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TSequenceFromPointer(p unsafe.Pointer) *TSequence { + if p == nil { + return nil + } + v := &TSequence{} + v.ptr = p + return v +} + +// TSequenceMake is MEOS tsequence_make. +func TSequenceMake(instants unsafe.Pointer, count int, lower_inc bool, upper_inc bool, interp functions.Interpolation, normalize bool) (*Temporal, error) { + _r0, _err := functions.TsequenceMake(instants, count, lower_inc, upper_inc, interp, normalize) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tsequenceset.go b/types/tsequenceset.go new file mode 100644 index 0000000..f84319f --- /dev/null +++ b/types/tsequenceset.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TSequenceSet struct { + Temporal +} + +// TSequenceSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TSequenceSetFromPointer(p unsafe.Pointer) *TSequenceSet { + if p == nil { + return nil + } + v := &TSequenceSet{} + v.ptr = p + return v +} + +// TSequenceSetMake is MEOS tsequenceset_make. +func TSequenceSetMake(sequences unsafe.Pointer, count int, normalize bool) (*Temporal, error) { + _r0, _err := functions.TsequencesetMake(sequences, count, normalize) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tspatial.go b/types/tspatial.go new file mode 100644 index 0000000..2c1641a --- /dev/null +++ b/types/tspatial.go @@ -0,0 +1,98 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +// TSpatial is temporal types carrying an STBox spatial bounding box. + +type TSpatial struct { + Temporal +} + +// TSpatialFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TSpatialFromPointer(p unsafe.Pointer) *TSpatial { + if p == nil { + return nil + } + v := &TSpatial{} + v.ptr = p + return v +} + +// Out is MEOS tspatial_out. +func (x *TSpatial) Out(maxdd int) (string, error) { + _r0, _err := functions.TspatialOut(functions.TemporalFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// AsEWKT is MEOS tspatial_as_ewkt. +func (x *TSpatial) AsEWKT(maxdd int) (string, error) { + _r0, _err := functions.TspatialAsEWKT(functions.TemporalFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// AsText is MEOS tspatial_as_text. +func (x *TSpatial) AsText(maxdd int) (string, error) { + _r0, _err := functions.TspatialAsText(functions.TemporalFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// ToStbox is MEOS tspatial_to_stbox. +func (x *TSpatial) ToStbox() (*STBox, error) { + _r0, _err := functions.TspatialToSTBOX(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// SRID is MEOS tspatial_srid. +func (x *TSpatial) SRID() (int32, error) { + _r0, _err := functions.TspatialSRID(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// SetSRID is MEOS tspatial_set_srid. +func (x *TSpatial) SetSRID(srid int32) (*Temporal, error) { + _r0, _err := functions.TspatialSetSRID(functions.TemporalFromPointer(x.Pointer()), srid) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Transform is MEOS tspatial_transform. +func (x *TSpatial) Transform(srid int32) (*Temporal, error) { + _r0, _err := functions.TspatialTransform(functions.TemporalFromPointer(x.Pointer()), srid) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TransformPipeline is MEOS tspatial_transform_pipeline. +func (x *TSpatial) TransformPipeline(pipelinestr string, srid int32, is_forward bool) (*Temporal, error) { + _r0, _err := functions.TspatialTransformPipeline(functions.TemporalFromPointer(x.Pointer()), pipelinestr, srid, is_forward) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tstzset.go b/types/tstzset.go new file mode 100644 index 0000000..8264052 --- /dev/null +++ b/types/tstzset.go @@ -0,0 +1,108 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TsTzSet struct { + Set +} + +// TsTzSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TsTzSetFromPointer(p unsafe.Pointer) *TsTzSet { + if p == nil { + return nil + } + v := &TsTzSet{} + v.ptr = p + return v +} + +// TsTzSetIn is MEOS tstzset_in. +func TsTzSetIn(str string) (*Set, error) { + _r0, _err := functions.TstzsetIn(str) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS tstzset_out. +func (x *TsTzSet) Out() (string, error) { + _r0, _err := functions.TstzsetOut(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// TsTzSetMake is MEOS tstzset_make. +func TsTzSetMake(values unsafe.Pointer, count int) (*Set, error) { + _r0, _err := functions.TstzsetMake(values, count) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// ToDateset is MEOS tstzset_to_dateset. +func (x *TsTzSet) ToDateset() (*Set, error) { + _r0, _err := functions.TstzsetToDateset(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS tstzset_end_value. +func (x *TsTzSet) EndValue() (int64, error) { + _r0, _err := functions.TstzsetEndValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// StartValue is MEOS tstzset_start_value. +func (x *TsTzSet) StartValue() (int64, error) { + _r0, _err := functions.TstzsetStartValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ValueN is MEOS tstzset_value_n. +func (x *TsTzSet) ValueN(n int) (int64, bool, error) { + _found, _value, _err := functions.TstzsetValueN(functions.SetFromPointer(x.Pointer()), n) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// Values is MEOS tstzset_values. +func (x *TsTzSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TstzsetValues(functions.SetFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// ToStbox is MEOS tstzset_to_stbox. +func (x *TsTzSet) ToStbox() (*STBox, error) { + _r0, _err := functions.TstzsetToSTBOX(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} diff --git a/types/tstzspan.go b/types/tstzspan.go new file mode 100644 index 0000000..6924128 --- /dev/null +++ b/types/tstzspan.go @@ -0,0 +1,87 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TsTzSpan struct { + Span +} + +// TsTzSpanFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TsTzSpanFromPointer(p unsafe.Pointer) *TsTzSpan { + if p == nil { + return nil + } + v := &TsTzSpan{} + v.ptr = p + return v +} + +// TsTzSpanIn is MEOS tstzspan_in. +func TsTzSpanIn(str string) (*Span, error) { + _r0, _err := functions.TstzspanIn(str) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS tstzspan_out. +func (x *TsTzSpan) Out() (string, error) { + _r0, _err := functions.TstzspanOut(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// TsTzSpanMake is MEOS tstzspan_make. +func TsTzSpanMake(lower int64, upper int64, lower_inc bool, upper_inc bool) (*Span, error) { + _r0, _err := functions.TstzspanMake(lower, upper, lower_inc, upper_inc) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// ToDatespan is MEOS tstzspan_to_datespan. +func (x *TsTzSpan) ToDatespan() (*Span, error) { + _r0, _err := functions.TstzspanToDatespan(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Lower is MEOS tstzspan_lower. +func (x *TsTzSpan) Lower() (int64, error) { + _r0, _err := functions.TstzspanLower(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Upper is MEOS tstzspan_upper. +func (x *TsTzSpan) Upper() (int64, error) { + _r0, _err := functions.TstzspanUpper(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ToStbox is MEOS tstzspan_to_stbox. +func (x *TsTzSpan) ToStbox() (*STBox, error) { + _r0, _err := functions.TstzspanToSTBOX(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} diff --git a/types/tstzspanset.go b/types/tstzspanset.go new file mode 100644 index 0000000..696b7bf --- /dev/null +++ b/types/tstzspanset.go @@ -0,0 +1,126 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TsTzSpanSet struct { + SpanSet +} + +// TsTzSpanSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TsTzSpanSetFromPointer(p unsafe.Pointer) *TsTzSpanSet { + if p == nil { + return nil + } + v := &TsTzSpanSet{} + v.ptr = p + return v +} + +// TsTzSpanSetIn is MEOS tstzspanset_in. +func TsTzSpanSetIn(str string) (*SpanSet, error) { + _r0, _err := functions.TstzspansetIn(str) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS tstzspanset_out. +func (x *TsTzSpanSet) Out() (string, error) { + _r0, _err := functions.TstzspansetOut(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// ToDatespanset is MEOS tstzspanset_to_datespanset. +func (x *TsTzSpanSet) ToDatespanset() (*SpanSet, error) { + _r0, _err := functions.TstzspansetToDatespanset(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// EndTimestamptz is MEOS tstzspanset_end_timestamptz. +func (x *TsTzSpanSet) EndTimestamptz() (int64, error) { + _r0, _err := functions.TstzspansetEndTimestamptz(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Lower is MEOS tstzspanset_lower. +func (x *TsTzSpanSet) Lower() (int64, error) { + _r0, _err := functions.TstzspansetLower(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// NumTimestamps is MEOS tstzspanset_num_timestamps. +func (x *TsTzSpanSet) NumTimestamps() (int, error) { + _r0, _err := functions.TstzspansetNumTimestamps(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// StartTimestamptz is MEOS tstzspanset_start_timestamptz. +func (x *TsTzSpanSet) StartTimestamptz() (int64, error) { + _r0, _err := functions.TstzspansetStartTimestamptz(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Timestamps is MEOS tstzspanset_timestamps. +func (x *TsTzSpanSet) Timestamps() (*Set, error) { + _r0, _err := functions.TstzspansetTimestamps(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// TimestamptzN is MEOS tstzspanset_timestamptz_n. +func (x *TsTzSpanSet) TimestamptzN(n int) (int64, bool, error) { + _found, _value, _err := functions.TstzspansetTimestamptzN(functions.SpanSetFromPointer(x.Pointer()), n) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// Upper is MEOS tstzspanset_upper. +func (x *TsTzSpanSet) Upper() (int64, error) { + _r0, _err := functions.TstzspansetUpper(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ToStbox is MEOS tstzspanset_to_stbox. +func (x *TsTzSpanSet) ToStbox() (*STBox, error) { + _r0, _err := functions.TstzspansetToSTBOX(functions.SpanSetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} diff --git a/types/ttext.go b/types/ttext.go new file mode 100644 index 0000000..641aaf1 --- /dev/null +++ b/types/ttext.go @@ -0,0 +1,183 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TText struct { + TAlpha +} + +// TTextFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TTextFromPointer(p unsafe.Pointer) *TText { + if p == nil { + return nil + } + v := &TText{} + v.ptr = p + return v +} + +// TTextFromMFJSON is MEOS ttext_from_mfjson. +func TTextFromMFJSON(str string) (*Temporal, error) { + _r0, _err := functions.TtextFromMFJSON(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TTextIn is MEOS ttext_in. +func TTextIn(str string) (*Temporal, error) { + _r0, _err := functions.TtextIn(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS ttext_out. +func (x *TText) Out() (string, error) { + _r0, _err := functions.TtextOut(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// TTextFromBaseTemp is MEOS ttext_from_base_temp. +func TTextFromBaseTemp(txt string, temp *Temporal) (*Temporal, error) { + _r0, _err := functions.TtextFromBaseTemp(txt, functions.TemporalFromPointer(temp.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS ttext_end_value. +func (x *TText) EndValue() (string, error) { + _r0, _err := functions.TtextEndValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// MaxValue is MEOS ttext_max_value. +func (x *TText) MaxValue() (string, error) { + _r0, _err := functions.TtextMaxValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// MinValue is MEOS ttext_min_value. +func (x *TText) MinValue() (string, error) { + _r0, _err := functions.TtextMinValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// StartValue is MEOS ttext_start_value. +func (x *TText) StartValue() (string, error) { + _r0, _err := functions.TtextStartValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// ValueAtTimestamptz is MEOS ttext_value_at_timestamptz. +func (x *TText) ValueAtTimestamptz(t int64, strict bool) (string, bool, error) { + _found, _value, _err := functions.TtextValueAtTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, strict) + if _err != nil { + return "", false, _err + } + if !_found { + return "", false, nil + } + return _value, true, nil +} + +// ValueN is MEOS ttext_value_n. +func (x *TText) ValueN(n int) (string, bool, error) { + _found, _value, _err := functions.TtextValueN(functions.TemporalFromPointer(x.Pointer()), n) + if _err != nil { + return "", false, _err + } + if !_found { + return "", false, nil + } + return _value, true, nil +} + +// Values is MEOS ttext_values. +func (x *TText) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TtextValues(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// AtValue is MEOS ttext_at_value. +func (x *TText) AtValue(txt string) (*Temporal, error) { + _r0, _err := functions.TtextAtValue(functions.TemporalFromPointer(x.Pointer()), txt) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusValue is MEOS ttext_minus_value. +func (x *TText) MinusValue(txt string) (*Temporal, error) { + _r0, _err := functions.TtextMinusValue(functions.TemporalFromPointer(x.Pointer()), txt) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Initcap is MEOS ttext_initcap. +func (x *TText) Initcap() (*Temporal, error) { + _r0, _err := functions.TtextInitcap(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Upper is MEOS ttext_upper. +func (x *TText) Upper() (*Temporal, error) { + _r0, _err := functions.TtextUpper(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Lower is MEOS ttext_lower. +func (x *TText) Lower() (*Temporal, error) { + _r0, _err := functions.TtextLower(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTjsonb is MEOS ttext_to_tjsonb. +func (x *TText) ToTjsonb() (*Temporal, error) { + _r0, _err := functions.TtextToTjsonb(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/ttextinst.go b/types/ttextinst.go new file mode 100644 index 0000000..c51aacd --- /dev/null +++ b/types/ttextinst.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TTextInst struct { + handle +} + +// TTextInstFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TTextInstFromPointer(p unsafe.Pointer) *TTextInst { + if p == nil { + return nil + } + v := &TTextInst{} + v.ptr = p + return v +} + +// TTextInstMake is MEOS ttextinst_make. +func TTextInstMake(txt string, t int64) (*Temporal, error) { + _r0, _err := functions.TtextinstMake(txt, t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/ttextseq.go b/types/ttextseq.go new file mode 100644 index 0000000..810fa58 --- /dev/null +++ b/types/ttextseq.go @@ -0,0 +1,42 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TTextSeq struct { + handle +} + +// TTextSeqFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TTextSeqFromPointer(p unsafe.Pointer) *TTextSeq { + if p == nil { + return nil + } + v := &TTextSeq{} + v.ptr = p + return v +} + +// TTextSeqFromBaseTstzset is MEOS ttextseq_from_base_tstzset. +func TTextSeqFromBaseTstzset(txt string, s *Set) (*Temporal, error) { + _r0, _err := functions.TtextseqFromBaseTstzset(txt, functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TTextSeqFromBaseTstzspan is MEOS ttextseq_from_base_tstzspan. +func TTextSeqFromBaseTstzspan(txt string, s *Span) (*Temporal, error) { + _r0, _err := functions.TtextseqFromBaseTstzspan(txt, functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/ttextseqset.go b/types/ttextseqset.go new file mode 100644 index 0000000..7ddb239 --- /dev/null +++ b/types/ttextseqset.go @@ -0,0 +1,33 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TTextSeqSet struct { + handle +} + +// TTextSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TTextSeqSetFromPointer(p unsafe.Pointer) *TTextSeqSet { + if p == nil { + return nil + } + v := &TTextSeqSet{} + v.ptr = p + return v +} + +// TTextSeqSetFromBaseTstzspanset is MEOS ttextseqset_from_base_tstzspanset. +func TTextSeqSetFromBaseTstzspanset(txt string, ss *SpanSet) (*Temporal, error) { + _r0, _err := functions.TtextseqsetFromBaseTstzspanset(txt, functions.SpanSetFromPointer(ss.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/value.go b/types/value.go new file mode 100644 index 0000000..4cb9b0e --- /dev/null +++ b/types/value.go @@ -0,0 +1,22 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" +) + +type Value struct { + handle +} + +// ValueFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func ValueFromPointer(p unsafe.Pointer) *Value { + if p == nil { + return nil + } + v := &Value{} + v.ptr = p + return v +}