From 27e8d8cbf9401972c771717e935dc0ac9656a260 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Esteban=20Zim=C3=A1nyi?= Date: Sun, 1 Nov 2026 17:20:29 +0100 Subject: [PATCH] Regenerate the binding from MobilityDB master 91f8d676e7 The flat functions and the object layer are those tools/codegen.py and tools/objectgen.py write from the catalog of MobilityDB 91f8d676e7 and MEOS-API 9069a08: 4702 wrappers and 150 classes with 1781 methods. Every temporal and set type MEOS holds by pointer has its class: TH3Index, TQuadbin and TS2Cell under TCellIndex, TPcpoint, TPcpatch and TPoseChain under TSpatial, the cell, point cloud and pose chain sets under SpatialSet, GeomSet and GeogSet under GeoSet, and JsonbSet under Set; and each format method takes its portable spelling, AsHexWKB, AsHexEWKB, FromHexWKB, FromHexEWKB, AsGeoJSON and FromGeoJSON. A method may not share the name of the struct its class embeds, so a method whose name is its parent's takes the name of its SQL function: jsonbset_set, which reads set on JsonbSet, whose parent is Set, is JsonbsetSet, as its SQL function jsonbsetSet. Measured: the functions and types packages build with no go vet finding, the parity tests pass, and the 122 examples of the root package pass under TZ=UTC, as the workflow runs them. --- functions/meos_meos.go | 550 ++++++++++++++++++++++++++++ functions/meos_meos_cbuffer.go | 11 + functions/meos_meos_geo.go | 52 ++- functions/meos_meos_internal.go | 55 +++ functions/meos_meos_internal_geo.go | 33 ++ functions/meos_meos_json.go | 44 +++ functions/meos_meos_npoint.go | 11 + functions/meos_meos_pointcloud.go | 11 + functions/meos_meos_pose.go | 202 ++++++++++ functions/meos_meos_quadbin.go | 11 + functions/meos_meos_raster.go | 4 +- functions/meos_meos_rgeo.go | 12 + functions/meos_meos_s2cell.go | 11 + functions/meos_pg_time.go | 4 +- functions/meos_pg_timestamp.go | 4 +- tools/objectgen.py | 7 + types/cbuffer.go | 12 +- types/cbufferset.go | 2 +- types/geo.go | 25 +- types/geography.go | 4 +- types/geogset.go | 2 +- types/geometry.go | 4 +- types/geomset.go | 59 +-- types/geoset.go | 81 ++++ types/h3indexset.go | 108 ++++++ types/jsonbset.go | 333 +++++++++++++++++ types/npoint.go | 12 +- types/npointset.go | 2 +- types/nsegment.go | 12 +- types/pcpatch.go | 8 +- types/pcpatchset.go | 90 +++++ types/pcpoint.go | 8 +- types/pcpointset.go | 90 +++++ types/pose.go | 12 +- types/posechain.go | 12 +- types/posechainset.go | 78 ++++ types/poseset.go | 2 +- types/quadbinset.go | 126 +++++++ types/raquet.go | 8 +- types/raster.go | 12 +- types/s2cellset.go | 117 ++++++ types/set.go | 8 +- types/span.go | 8 +- types/spanset.go | 8 +- types/spatialset.go | 114 ++++++ types/stbox.go | 12 +- types/tbox.go | 8 +- types/tcellindex.go | 80 ++++ types/temporal.go | 8 +- types/tgeo.go | 13 +- types/th3index.go | 372 +++++++++++++++++++ types/th3indexinst.go | 33 ++ types/th3indexseq.go | 51 +++ types/th3indexseqset.go | 42 +++ types/tpcbox.go | 12 +- types/tpcpatch.go | 192 ++++++++++ types/tpcpatchinst.go | 33 ++ types/tpcpatchseq.go | 42 +++ types/tpcpatchseqset.go | 33 ++ types/tpcpoint.go | 165 +++++++++ types/tpcpointinst.go | 33 ++ types/tpcpointseq.go | 42 +++ types/tpcpointseqset.go | 33 ++ types/tposechain.go | 195 ++++++++++ types/tposechaininst.go | 33 ++ types/tposechainseq.go | 42 +++ types/tposechainseqset.go | 33 ++ types/tquadbin.go | 183 +++++++++ types/tquadbininst.go | 33 ++ types/tquadbinseq.go | 51 +++ types/tquadbinseqset.go | 42 +++ types/trgeometry.go | 12 + types/ts2cell.go | 183 +++++++++ types/ts2cellinst.go | 33 ++ types/ts2cellseq.go | 51 +++ types/ts2cellseqset.go | 42 +++ types/tspatial.go | 4 +- 77 files changed, 4352 insertions(+), 168 deletions(-) create mode 100644 types/geoset.go create mode 100644 types/h3indexset.go create mode 100644 types/jsonbset.go create mode 100644 types/pcpatchset.go create mode 100644 types/pcpointset.go create mode 100644 types/posechainset.go create mode 100644 types/quadbinset.go create mode 100644 types/s2cellset.go create mode 100644 types/spatialset.go create mode 100644 types/tcellindex.go create mode 100644 types/th3index.go create mode 100644 types/th3indexinst.go create mode 100644 types/th3indexseq.go create mode 100644 types/th3indexseqset.go create mode 100644 types/tpcpatch.go create mode 100644 types/tpcpatchinst.go create mode 100644 types/tpcpatchseq.go create mode 100644 types/tpcpatchseqset.go create mode 100644 types/tpcpoint.go create mode 100644 types/tpcpointinst.go create mode 100644 types/tpcpointseq.go create mode 100644 types/tpcpointseqset.go create mode 100644 types/tposechain.go create mode 100644 types/tposechaininst.go create mode 100644 types/tposechainseq.go create mode 100644 types/tposechainseqset.go create mode 100644 types/tquadbin.go create mode 100644 types/tquadbininst.go create mode 100644 types/tquadbinseq.go create mode 100644 types/tquadbinseqset.go create mode 100644 types/ts2cell.go create mode 100644 types/ts2cellinst.go create mode 100644 types/ts2cellseq.go create mode 100644 types/ts2cellseqset.go diff --git a/functions/meos_meos.go b/functions/meos_meos.go index 6798070..0d19c3c 100644 --- a/functions/meos_meos.go +++ b/functions/meos_meos.go @@ -3675,6 +3675,28 @@ func TimestamptzTprecision(t int64, duration *Interval, torigin int64) (_r0 int6 } +// TstzsetScale wraps MEOS C function tstzset_scale. +func TstzsetScale(s *Set, duration *Interval) (_r0 *Set, _err error) { + C.meos_errno_reset() + _cret := C.tstzset_scale(s._inner, duration._inner) + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil +} + + +// TstzsetShift wraps MEOS C function tstzset_shift. +func TstzsetShift(s *Set, shift *Interval) (_r0 *Set, _err error) { + C.meos_errno_reset() + _cret := C.tstzset_shift(s._inner, shift._inner) + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil +} + + // TstzsetShiftScale wraps MEOS C function tstzset_shift_scale. func TstzsetShiftScale(s *Set, shift *Interval, duration *Interval) (_r0 *Set, _err error) { C.meos_errno_reset() @@ -3697,6 +3719,28 @@ func TstzsetTprecision(s *Set, duration *Interval, torigin int64) (_r0 *Set, _er } +// TstzspanScale wraps MEOS C function tstzspan_scale. +func TstzspanScale(s *Span, duration *Interval) (_r0 *Span, _err error) { + C.meos_errno_reset() + _cret := C.tstzspan_scale(s._inner, duration._inner) + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil +} + + +// TstzspanShift wraps MEOS C function tstzspan_shift. +func TstzspanShift(s *Span, shift *Interval) (_r0 *Span, _err error) { + C.meos_errno_reset() + _cret := C.tstzspan_shift(s._inner, shift._inner) + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil +} + + // TstzspanShiftScale wraps MEOS C function tstzspan_shift_scale. func TstzspanShiftScale(s *Span, shift *Interval, duration *Interval) (_r0 *Span, _err error) { C.meos_errno_reset() @@ -3719,6 +3763,28 @@ func TstzspanTprecision(s *Span, duration *Interval, torigin int64) (_r0 *Span, } +// TstzspansetScale wraps MEOS C function tstzspanset_scale. +func TstzspansetScale(ss *SpanSet, duration *Interval) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() + _cret := C.tstzspanset_scale(ss._inner, duration._inner) + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil +} + + +// TstzspansetShift wraps MEOS C function tstzspanset_shift. +func TstzspansetShift(ss *SpanSet, shift *Interval) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() + _cret := C.tstzspanset_shift(ss._inner, shift._inner) + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil +} + + // TstzspansetShiftScale wraps MEOS C function tstzspanset_shift_scale. func TstzspansetShiftScale(ss *SpanSet, shift *Interval, duration *Interval) (_r0 *SpanSet, _err error) { C.meos_errno_reset() @@ -9207,6 +9273,17 @@ func TintboxShiftScale(box *TBox, shift int, width int, hasshift bool, haswidth } +// TBOXScaleTime wraps MEOS C function tbox_scale_time. +func TBOXScaleTime(box *TBox, duration *Interval) (_r0 *TBox, _err error) { + C.meos_errno_reset() + _cret := C.tbox_scale_time(box._inner, duration._inner) + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil +} + + // TBOXShiftScaleTime wraps MEOS C function tbox_shift_scale_time. func TBOXShiftScaleTime(box *TBox, shift *Interval, duration *Interval) (_r0 *TBox, _err error) { C.meos_errno_reset() @@ -9218,6 +9295,17 @@ func TBOXShiftScaleTime(box *TBox, shift *Interval, duration *Interval) (_r0 *TB } +// TBOXShiftTime wraps MEOS C function tbox_shift_time. +func TBOXShiftTime(box *TBox, shift *Interval) (_r0 *TBox, _err error) { + C.meos_errno_reset() + _cret := C.tbox_shift_time(box._inner, shift._inner) + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil +} + + // TbigintboxExpand wraps MEOS C function tbigintbox_expand. func TbigintboxExpand(box *TBox, i int64) (_r0 *TBox, _err error) { C.meos_errno_reset() @@ -9405,6 +9493,402 @@ func RightTBOXTBOX(box1 *TBox, box2 *TBox) (_r0 bool, _err error) { } +// AdjacentNumspanTBOX wraps MEOS C function adjacent_numspan_tbox. +func AdjacentNumspanTBOX(s *Span, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.adjacent_numspan_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// AdjacentTBOXNumspan wraps MEOS C function adjacent_tbox_numspan. +func AdjacentTBOXNumspan(box *TBox, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.adjacent_tbox_numspan(box._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// AdjacentTBOXTstzspan wraps MEOS C function adjacent_tbox_tstzspan. +func AdjacentTBOXTstzspan(box *TBox, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.adjacent_tbox_tstzspan(box._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// AdjacentTstzspanTBOX wraps MEOS C function adjacent_tstzspan_tbox. +func AdjacentTstzspanTBOX(s *Span, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.adjacent_tstzspan_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// ContainedNumspanTBOX wraps MEOS C function contained_numspan_tbox. +func ContainedNumspanTBOX(s *Span, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.contained_numspan_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// ContainedTBOXNumspan wraps MEOS C function contained_tbox_numspan. +func ContainedTBOXNumspan(box *TBox, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.contained_tbox_numspan(box._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// ContainedTBOXTstzspan wraps MEOS C function contained_tbox_tstzspan. +func ContainedTBOXTstzspan(box *TBox, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.contained_tbox_tstzspan(box._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// ContainedTstzspanTBOX wraps MEOS C function contained_tstzspan_tbox. +func ContainedTstzspanTBOX(s *Span, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.contained_tstzspan_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// ContainsNumspanTBOX wraps MEOS C function contains_numspan_tbox. +func ContainsNumspanTBOX(s *Span, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.contains_numspan_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// ContainsTBOXNumspan wraps MEOS C function contains_tbox_numspan. +func ContainsTBOXNumspan(box *TBox, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.contains_tbox_numspan(box._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// ContainsTBOXTstzspan wraps MEOS C function contains_tbox_tstzspan. +func ContainsTBOXTstzspan(box *TBox, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.contains_tbox_tstzspan(box._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// ContainsTstzspanTBOX wraps MEOS C function contains_tstzspan_tbox. +func ContainsTstzspanTBOX(s *Span, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.contains_tstzspan_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// OverlapsNumspanTBOX wraps MEOS C function overlaps_numspan_tbox. +func OverlapsNumspanTBOX(s *Span, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.overlaps_numspan_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// OverlapsTBOXNumspan wraps MEOS C function overlaps_tbox_numspan. +func OverlapsTBOXNumspan(box *TBox, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.overlaps_tbox_numspan(box._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// OverlapsTBOXTstzspan wraps MEOS C function overlaps_tbox_tstzspan. +func OverlapsTBOXTstzspan(box *TBox, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.overlaps_tbox_tstzspan(box._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// OverlapsTstzspanTBOX wraps MEOS C function overlaps_tstzspan_tbox. +func OverlapsTstzspanTBOX(s *Span, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.overlaps_tstzspan_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// SameNumspanTBOX wraps MEOS C function same_numspan_tbox. +func SameNumspanTBOX(s *Span, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.same_numspan_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// SameTBOXNumspan wraps MEOS C function same_tbox_numspan. +func SameTBOXNumspan(box *TBox, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.same_tbox_numspan(box._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// SameTBOXTstzspan wraps MEOS C function same_tbox_tstzspan. +func SameTBOXTstzspan(box *TBox, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.same_tbox_tstzspan(box._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// SameTstzspanTBOX wraps MEOS C function same_tstzspan_tbox. +func SameTstzspanTBOX(s *Span, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.same_tstzspan_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// AfterTBOXTstzspan wraps MEOS C function after_tbox_tstzspan. +func AfterTBOXTstzspan(box *TBox, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.after_tbox_tstzspan(box._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// AfterTstzspanTBOX wraps MEOS C function after_tstzspan_tbox. +func AfterTstzspanTBOX(s *Span, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.after_tstzspan_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// BeforeTBOXTstzspan wraps MEOS C function before_tbox_tstzspan. +func BeforeTBOXTstzspan(box *TBox, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.before_tbox_tstzspan(box._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// BeforeTstzspanTBOX wraps MEOS C function before_tstzspan_tbox. +func BeforeTstzspanTBOX(s *Span, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.before_tstzspan_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// LeftNumspanTBOX wraps MEOS C function left_numspan_tbox. +func LeftNumspanTBOX(s *Span, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.left_numspan_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// LeftTBOXNumspan wraps MEOS C function left_tbox_numspan. +func LeftTBOXNumspan(box *TBox, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.left_tbox_numspan(box._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// OverafterTBOXTstzspan wraps MEOS C function overafter_tbox_tstzspan. +func OverafterTBOXTstzspan(box *TBox, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.overafter_tbox_tstzspan(box._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// OverafterTstzspanTBOX wraps MEOS C function overafter_tstzspan_tbox. +func OverafterTstzspanTBOX(s *Span, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.overafter_tstzspan_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// OverbeforeTBOXTstzspan wraps MEOS C function overbefore_tbox_tstzspan. +func OverbeforeTBOXTstzspan(box *TBox, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.overbefore_tbox_tstzspan(box._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// OverbeforeTstzspanTBOX wraps MEOS C function overbefore_tstzspan_tbox. +func OverbeforeTstzspanTBOX(s *Span, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.overbefore_tstzspan_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// OverleftNumspanTBOX wraps MEOS C function overleft_numspan_tbox. +func OverleftNumspanTBOX(s *Span, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.overleft_numspan_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// OverleftTBOXNumspan wraps MEOS C function overleft_tbox_numspan. +func OverleftTBOXNumspan(box *TBox, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.overleft_tbox_numspan(box._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// OverrightNumspanTBOX wraps MEOS C function overright_numspan_tbox. +func OverrightNumspanTBOX(s *Span, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.overright_numspan_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// OverrightTBOXNumspan wraps MEOS C function overright_tbox_numspan. +func OverrightTBOXNumspan(box *TBox, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.overright_tbox_numspan(box._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// RightNumspanTBOX wraps MEOS C function right_numspan_tbox. +func RightNumspanTBOX(s *Span, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.right_numspan_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// RightTBOXNumspan wraps MEOS C function right_tbox_numspan. +func RightTBOXNumspan(box *TBox, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.right_tbox_numspan(box._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + // TBOXCmp wraps MEOS C function tbox_cmp. func TBOXCmp(box1 *TBox, box2 *TBox) (_r0 int, _err error) { C.meos_errno_reset() @@ -15531,6 +16015,17 @@ func TdistanceTnumberTnumber(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _ } +// NadBigintspanTBOX wraps MEOS C function nad_bigintspan_tbox. +func NadBigintspanTBOX(s *Span, box *TBox) (_r0 int64, _err error) { + C.meos_errno_reset() + _cret := C.nad_bigintspan_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil +} + + // NadTboxfloatTboxfloat wraps MEOS C function nad_tboxfloat_tboxfloat. func NadTboxfloatTboxfloat(box1 *TBox, box2 *TBox) (_r0 float64, _err error) { C.meos_errno_reset() @@ -15542,6 +16037,17 @@ func NadTboxfloatTboxfloat(box1 *TBox, box2 *TBox) (_r0 float64, _err error) { } +// NadFloatspanTBOX wraps MEOS C function nad_floatspan_tbox. +func NadFloatspanTBOX(s *Span, box *TBox) (_r0 float64, _err error) { + C.meos_errno_reset() + _cret := C.nad_floatspan_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil +} + + // NadTboxintTboxint wraps MEOS C function nad_tboxint_tboxint. func NadTboxintTboxint(box1 *TBox, box2 *TBox) (_r0 int, _err error) { C.meos_errno_reset() @@ -15553,6 +16059,17 @@ func NadTboxintTboxint(box1 *TBox, box2 *TBox) (_r0 int, _err error) { } +// NadIntspanTBOX wraps MEOS C function nad_intspan_tbox. +func NadIntspanTBOX(s *Span, box *TBox) (_r0 int, _err error) { + C.meos_errno_reset() + _cret := C.nad_intspan_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil +} + + // NadTfloatFloat wraps MEOS C function nad_tfloat_float. func NadTfloatFloat(temp *Temporal, d float64) (_r0 float64, _err error) { C.meos_errno_reset() @@ -15564,6 +16081,17 @@ func NadTfloatFloat(temp *Temporal, d float64) (_r0 float64, _err error) { } +// NadTfloatFloatspan wraps MEOS C function nad_tfloat_floatspan. +func NadTfloatFloatspan(temp *Temporal, s *Span) (_r0 float64, _err error) { + C.meos_errno_reset() + _cret := C.nad_tfloat_floatspan(temp._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil +} + + // NadTfloatTfloat wraps MEOS C function nad_tfloat_tfloat. func NadTfloatTfloat(temp1 *Temporal, temp2 *Temporal) (_r0 float64, _err error) { C.meos_errno_reset() @@ -15597,6 +16125,17 @@ func NadTbigintBigint(temp *Temporal, i int64) (_r0 int64, _err error) { } +// NadTbigintBigintspan wraps MEOS C function nad_tbigint_bigintspan. +func NadTbigintBigintspan(temp *Temporal, s *Span) (_r0 int64, _err error) { + C.meos_errno_reset() + _cret := C.nad_tbigint_bigintspan(temp._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil +} + + // NadTbigintTBOX wraps MEOS C function nad_tbigint_tbox. func NadTbigintTBOX(temp *Temporal, box *TBox) (_r0 int64, _err error) { C.meos_errno_reset() @@ -15641,6 +16180,17 @@ func NadTintInt(temp *Temporal, i int) (_r0 int, _err error) { } +// NadTintIntspan wraps MEOS C function nad_tint_intspan. +func NadTintIntspan(temp *Temporal, s *Span) (_r0 int, _err error) { + C.meos_errno_reset() + _cret := C.nad_tint_intspan(temp._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil +} + + // NadTintTBOX wraps MEOS C function nad_tint_tbox. func NadTintTBOX(temp *Temporal, box *TBox) (_r0 int, _err error) { C.meos_errno_reset() diff --git a/functions/meos_meos_cbuffer.go b/functions/meos_meos_cbuffer.go index 90b6f07..d1ad423 100644 --- a/functions/meos_meos_cbuffer.go +++ b/functions/meos_meos_cbuffer.go @@ -813,6 +813,17 @@ func UnionSetCbuffer(s *Set, cb *Cbuffer) (_r0 *Set, _err error) { } +// DistanceCbuffersetCbufferset wraps MEOS C function distance_cbufferset_cbufferset. +func DistanceCbuffersetCbufferset(s1 *Set, s2 *Set) (_r0 float64, _err error) { + C.meos_errno_reset() + _cret := C.distance_cbufferset_cbufferset(s1._inner, s2._inner) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil +} + + // TcbufferIn wraps MEOS C function tcbuffer_in. func TcbufferIn(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) diff --git a/functions/meos_meos_geo.go b/functions/meos_meos_geo.go index 1f1fd6a..494c7f6 100644 --- a/functions/meos_meos_geo.go +++ b/functions/meos_meos_geo.go @@ -728,9 +728,20 @@ func GeoScale(gs *Geom, xfactor float64, yfactor float64, zfactor float64) (_r0 // GeoScaleGeo wraps MEOS C function geo_scale_geo. -func GeoScaleGeo(gs *Geom, scale *Geom, sorigin *Geom) (_r0 *Geom, _err error) { +func GeoScaleGeo(gs *Geom, scale *Geom) (_r0 *Geom, _err error) { C.meos_errno_reset() - _cret := C.geo_scale_geo(gs._inner, scale._inner, sorigin._inner) + _cret := C.geo_scale_geo(gs._inner, scale._inner) + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil +} + + +// GeoScaleGeoOrigin wraps MEOS C function geo_scale_geo_origin. +func GeoScaleGeoOrigin(gs *Geom, scale *Geom, sorigin *Geom) (_r0 *Geom, _err error) { + C.meos_errno_reset() + _cret := C.geo_scale_geo_origin(gs._inner, scale._inner, sorigin._inner) if _err = meosError(); _err != nil { return } @@ -2324,6 +2335,17 @@ func STBOXRound(box *STBox, maxdd int) (_r0 *STBox, _err error) { } +// STBOXScaleTime wraps MEOS C function stbox_scale_time. +func STBOXScaleTime(box *STBox, duration *Interval) (_r0 *STBox, _err error) { + C.meos_errno_reset() + _cret := C.stbox_scale_time(box._inner, duration._inner) + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil +} + + // STBOXShiftScaleTime wraps MEOS C function stbox_shift_scale_time. func STBOXShiftScaleTime(box *STBox, shift *Interval, duration *Interval) (_r0 *STBox, _err error) { C.meos_errno_reset() @@ -2335,6 +2357,17 @@ func STBOXShiftScaleTime(box *STBox, shift *Interval, duration *Interval) (_r0 * } +// STBOXShiftTime wraps MEOS C function stbox_shift_time. +func STBOXShiftTime(box *STBox, shift *Interval) (_r0 *STBox, _err error) { + C.meos_errno_reset() + _cret := C.stbox_shift_time(box._inner, shift._inner) + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil +} + + // StboxarrRound wraps MEOS C function stboxarr_round. func StboxarrRound(boxarr *STBox, count int, maxdd int) (_r0 *STBox, _err error) { C.meos_errno_reset() @@ -3529,9 +3562,20 @@ func TgeoScale(temp *Temporal, xfactor float64, yfactor float64, zfactor float64 // TgeoScaleGeo wraps MEOS C function tgeo_scale_geo. -func TgeoScaleGeo(temp *Temporal, scale *Geom, sorigin *Geom) (_r0 *Temporal, _err error) { +func TgeoScaleGeo(temp *Temporal, scale *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() + _cret := C.tgeo_scale_geo(temp._inner, scale._inner) + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil +} + + +// TgeoScaleGeoOrigin wraps MEOS C function tgeo_scale_geo_origin. +func TgeoScaleGeoOrigin(temp *Temporal, scale *Geom, sorigin *Geom) (_r0 *Temporal, _err error) { C.meos_errno_reset() - _cret := C.tgeo_scale_geo(temp._inner, scale._inner, sorigin._inner) + _cret := C.tgeo_scale_geo_origin(temp._inner, scale._inner, sorigin._inner) if _err = meosError(); _err != nil { return } diff --git a/functions/meos_meos_internal.go b/functions/meos_meos_internal.go index e86005a..54b498d 100644 --- a/functions/meos_meos_internal.go +++ b/functions/meos_meos_internal.go @@ -447,6 +447,39 @@ func IntspanSetFloatspan(s1 *Span, s2 *Span) (_err error) { } +// TstzsetShiftScaleIntl wraps MEOS C function tstzset_shift_scale_intl. +func TstzsetShiftScaleIntl(s *Set, shift *Interval, duration *Interval) (_r0 *Set, _err error) { + C.meos_errno_reset() + _cret := C.tstzset_shift_scale_intl(s._inner, shift._inner, duration._inner) + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil +} + + +// TstzspanShiftScaleIntl wraps MEOS C function tstzspan_shift_scale_intl. +func TstzspanShiftScaleIntl(s *Span, shift *Interval, duration *Interval) (_r0 *Span, _err error) { + C.meos_errno_reset() + _cret := C.tstzspan_shift_scale_intl(s._inner, shift._inner, duration._inner) + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil +} + + +// TstzspansetShiftScaleIntl wraps MEOS C function tstzspanset_shift_scale_intl. +func TstzspansetShiftScaleIntl(ss *SpanSet, shift *Interval, duration *Interval) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() + _cret := C.tstzspanset_shift_scale_intl(ss._inner, shift._inner, duration._inner) + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil +} + + // SetCompact wraps MEOS C function set_compact. func SetCompact(s *Set) (_r0 *Set, _err error) { C.meos_errno_reset() @@ -917,6 +950,17 @@ func TstzspanSetTBOX(s *Span, box *TBox) (_err error) { } +// TBOXShiftScaleTimeIntl wraps MEOS C function tbox_shift_scale_time_intl. +func TBOXShiftScaleTimeIntl(box *TBox, shift *Interval, duration *Interval) (_r0 *TBox, _err error) { + C.meos_errno_reset() + _cret := C.tbox_shift_scale_time_intl(box._inner, shift._inner, duration._inner) + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil +} + + // TBOXExpand wraps MEOS C function tbox_expand. func TBOXExpand(box1 *TBox, box2 *TBox) (_err error) { C.meos_errno_reset() @@ -2217,6 +2261,17 @@ func TinstantAsTsequenceset(inst *TInstant, interp Interpolation) (_r0 *TSequenc } +// TemporalShiftScaleTimeIntl wraps MEOS C function temporal_shift_scale_time_intl. +func TemporalShiftScaleTimeIntl(temp *Temporal, shift *Interval, duration *Interval) (_r0 *Temporal, _err error) { + C.meos_errno_reset() + _cret := C.temporal_shift_scale_time_intl(temp._inner, shift._inner, duration._inner) + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil +} + + // TsequenceRestart wraps MEOS C function tsequence_restart. func TsequenceRestart(seq *TSequence, count int) (_err error) { C.meos_errno_reset() diff --git a/functions/meos_meos_internal_geo.go b/functions/meos_meos_internal_geo.go index 9b2b264..e2df940 100644 --- a/functions/meos_meos_internal_geo.go +++ b/functions/meos_meos_internal_geo.go @@ -127,6 +127,17 @@ func PointRound(gs *Geom, maxdd int) (_r0 *Geom, _err error) { } +// GeoScaleGeoIntl wraps MEOS C function geo_scale_geo_intl. +func GeoScaleGeoIntl(gs *Geom, scale *Geom, sorigin *Geom) (_r0 *Geom, _err error) { + C.meos_errno_reset() + _cret := C.geo_scale_geo_intl(gs._inner, scale._inner, sorigin._inner) + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil +} + + // STBOXSet wraps MEOS C function stbox_set. func STBOXSet(hasx bool, hasz bool, geodetic bool, srid int32, xmin float64, xmax float64, ymin float64, ymax float64, zmin float64, zmax float64, s *Span) (_r0 *STBox, _err error) { var _out_result C.STBox @@ -270,6 +281,17 @@ func STBOXExpandSpaceSet(box *STBox, d float64) (_r0 bool, _r1 *STBox, _err erro } +// STBOXShiftScaleTimeIntl wraps MEOS C function stbox_shift_scale_time_intl. +func STBOXShiftScaleTimeIntl(box *STBox, shift *Interval, duration *Interval) (_r0 *STBox, _err error) { + C.meos_errno_reset() + _cret := C.stbox_shift_scale_time_intl(box._inner, shift._inner, duration._inner) + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil +} + + // STBOXContains wraps MEOS C function stbox_contains. func STBOXContains(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { C.meos_errno_reset() @@ -691,6 +713,17 @@ func TgeometryseqsetIn(str string) (_r0 *TSequenceSet, _err error) { } +// TgeoScaleGeoIntl wraps MEOS C function tgeo_scale_geo_intl. +func TgeoScaleGeoIntl(temp *Temporal, scale *Geom, sorigin *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() + _cret := C.tgeo_scale_geo_intl(temp._inner, scale._inner, sorigin._inner) + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil +} + + // TspatialSetSTBOX wraps MEOS C function tspatial_set_stbox. func TspatialSetSTBOX(temp *Temporal) (_r0 *STBox, _err error) { var _out_result C.STBox diff --git a/functions/meos_meos_json.go b/functions/meos_meos_json.go index 23e3964..4a7d253 100644 --- a/functions/meos_meos_json.go +++ b/functions/meos_meos_json.go @@ -1464,6 +1464,28 @@ func JsonbsetObjectFieldCommon(set *Set, key string, astext bool, null_handle Nu } +// JsonbsetPathExistsIntl wraps MEOS C function jsonbset_path_exists_intl. +func JsonbsetPathExistsIntl(set *Set, jp *JsonPath, vars *Jsonb, silent bool, tz bool, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.jsonbset_path_exists_intl(set._inner, jp._inner, vars._inner, C.bool(silent), C.bool(tz), (*C.int)(unsafe.Pointer(count))) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} + + +// JsonbsetPathMatchIntl wraps MEOS C function jsonbset_path_match_intl. +func JsonbsetPathMatchIntl(set *Set, jp *JsonPath, vars *Jsonb, silent bool, tz bool, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.jsonbset_path_match_intl(set._inner, jp._inner, vars._inner, C.bool(silent), C.bool(tz), (*C.int)(unsafe.Pointer(count))) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} + + // ContainedJsonbSet wraps MEOS C function contained_jsonb_set. func ContainedJsonbSet(jb *Jsonb, s *Set) (_r0 bool, _err error) { C.meos_errno_reset() @@ -2338,6 +2360,28 @@ func TjsonbObjectFieldCommon(temp *Temporal, key string, astext bool, null_handl } +// TjsonbPathExistsIntl wraps MEOS C function tjsonb_path_exists_intl. +func TjsonbPathExistsIntl(temp *Temporal, jp *JsonPath, vars *Jsonb, silent bool, tz bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() + _cret := C.tjsonb_path_exists_intl(temp._inner, jp._inner, vars._inner, C.bool(silent), C.bool(tz)) + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil +} + + +// TjsonbPathMatchIntl wraps MEOS C function tjsonb_path_match_intl. +func TjsonbPathMatchIntl(temp *Temporal, jp *JsonPath, vars *Jsonb, silent bool, tz bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() + _cret := C.tjsonb_path_match_intl(temp._inner, jp._inner, vars._inner, C.bool(silent), C.bool(tz)) + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil +} + + // TjsonbAtValue wraps MEOS C function tjsonb_at_value. func TjsonbAtValue(temp *Temporal, jsb *Jsonb) (_r0 *Temporal, _err error) { C.meos_errno_reset() diff --git a/functions/meos_meos_npoint.go b/functions/meos_meos_npoint.go index e8ce3a6..4f23cb4 100644 --- a/functions/meos_meos_npoint.go +++ b/functions/meos_meos_npoint.go @@ -1007,6 +1007,17 @@ func UnionSetNpoint(s *Set, np *Npoint) (_r0 *Set, _err error) { } +// DistanceNpointsetNpointset wraps MEOS C function distance_npointset_npointset. +func DistanceNpointsetNpointset(s1 *Set, s2 *Set) (_r0 float64, _err error) { + C.meos_errno_reset() + _cret := C.distance_npointset_npointset(s1._inner, s2._inner) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil +} + + // TnpointIn wraps MEOS C function tnpoint_in. func TnpointIn(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) diff --git a/functions/meos_meos_pointcloud.go b/functions/meos_meos_pointcloud.go index a00aead..8f7cded 100644 --- a/functions/meos_meos_pointcloud.go +++ b/functions/meos_meos_pointcloud.go @@ -2393,6 +2393,17 @@ func TpcpatchNpoints(temp *Temporal) (_r0 int64, _err error) { } +// TpcpatchSwath wraps MEOS C function tpcpatch_swath. +func TpcpatchSwath(temp *Temporal, maxt *Interval) (_r0 *Geom, _err error) { + C.meos_errno_reset() + _cret := C.tpcpatch_swath(temp._inner, maxt._inner) + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil +} + + // EverEqPcpointTpcpoint wraps MEOS C function ever_eq_pcpoint_tpcpoint. func EverEqPcpointTpcpoint(pt *Pcpoint, temp *Temporal) (_r0 int, _err error) { C.meos_errno_reset() diff --git a/functions/meos_meos_pose.go b/functions/meos_meos_pose.go index a970bd4..6482e87 100644 --- a/functions/meos_meos_pose.go +++ b/functions/meos_meos_pose.go @@ -1111,6 +1111,17 @@ func UnionSetPose(s *Set, pose *Pose) (_r0 *Set, _err error) { } +// DistancePosesetPoseset wraps MEOS C function distance_poseset_poseset. +func DistancePosesetPoseset(s1 *Set, s2 *Set) (_r0 float64, _err error) { + C.meos_errno_reset() + _cret := C.distance_poseset_poseset(s1._inner, s2._inner) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil +} + + // TposeFromMFJSON wraps MEOS C function tpose_from_mfjson. func TposeFromMFJSON(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) @@ -2265,6 +2276,39 @@ func PosechainGe(pc1 unsafe.Pointer, pc2 unsafe.Pointer) (_r0 bool, _err error) } +// DistancePosechainGeo wraps MEOS C function distance_posechain_geo. +func DistancePosechainGeo(pc unsafe.Pointer, gs *Geom) (_r0 float64, _err error) { + C.meos_errno_reset() + _cret := C.distance_posechain_geo((*C.PoseChain)(unsafe.Pointer(pc)), gs._inner) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil +} + + +// DistancePosechainPosechain wraps MEOS C function distance_posechain_posechain. +func DistancePosechainPosechain(pc1 unsafe.Pointer, pc2 unsafe.Pointer) (_r0 float64, _err error) { + C.meos_errno_reset() + _cret := C.distance_posechain_posechain((*C.PoseChain)(unsafe.Pointer(pc1)), (*C.PoseChain)(unsafe.Pointer(pc2))) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil +} + + +// DistancePosechainSTBOX wraps MEOS C function distance_posechain_stbox. +func DistancePosechainSTBOX(pc unsafe.Pointer, box *STBox) (_r0 float64, _err error) { + C.meos_errno_reset() + _cret := C.distance_posechain_stbox((*C.PoseChain)(unsafe.Pointer(pc)), box._inner) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil +} + + // PosechainsetIn wraps MEOS C function posechainset_in. func PosechainsetIn(str string) (_r0 *Set, _err error) { _c_str := C.CString(str) @@ -2448,6 +2492,17 @@ func UnionSetPosechain(s *Set, pc unsafe.Pointer) (_r0 *Set, _err error) { } +// DistancePosechainsetPosechainset wraps MEOS C function distance_posechainset_posechainset. +func DistancePosechainsetPosechainset(s1 *Set, s2 *Set) (_r0 float64, _err error) { + C.meos_errno_reset() + _cret := C.distance_posechainset_posechainset(s1._inner, s2._inner) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil +} + + // TposechainIn wraps MEOS C function tposechain_in. func TposechainIn(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) @@ -2584,6 +2639,10 @@ func TposechainValue(temp *Temporal) (_r0 unsafe.Pointer, _err error) { } +// TODO tposechain_value_at_timestamptz: unhandled OUTPUT_SCALAR shape PoseChain ** +// func TposechainValueAtTimestamptz(...) { /* not yet handled by codegen */ } + + // TODO tposechain_value_n: unhandled OUTPUT_SCALAR shape PoseChain ** // func TposechainValueN(...) { /* not yet handled by codegen */ } @@ -2687,6 +2746,149 @@ func TposechainMinusValue(temp *Temporal, pc unsafe.Pointer) (_r0 *Temporal, _er } +// TdistanceTposechainGeo wraps MEOS C function tdistance_tposechain_geo. +func TdistanceTposechainGeo(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() + _cret := C.tdistance_tposechain_geo(temp._inner, gs._inner) + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil +} + + +// TdistanceTposechainPosechain wraps MEOS C function tdistance_tposechain_posechain. +func TdistanceTposechainPosechain(temp *Temporal, pc unsafe.Pointer) (_r0 *Temporal, _err error) { + C.meos_errno_reset() + _cret := C.tdistance_tposechain_posechain(temp._inner, (*C.PoseChain)(unsafe.Pointer(pc))) + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil +} + + +// TdistanceTposechainTposechain wraps MEOS C function tdistance_tposechain_tposechain. +func TdistanceTposechainTposechain(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() + _cret := C.tdistance_tposechain_tposechain(temp1._inner, temp2._inner) + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil +} + + +// NadTposechainGeo wraps MEOS C function nad_tposechain_geo. +func NadTposechainGeo(temp *Temporal, gs *Geom) (_r0 float64, _err error) { + C.meos_errno_reset() + _cret := C.nad_tposechain_geo(temp._inner, gs._inner) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil +} + + +// NadTposechainPosechain wraps MEOS C function nad_tposechain_posechain. +func NadTposechainPosechain(temp *Temporal, pc unsafe.Pointer) (_r0 float64, _err error) { + C.meos_errno_reset() + _cret := C.nad_tposechain_posechain(temp._inner, (*C.PoseChain)(unsafe.Pointer(pc))) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil +} + + +// NadTposechainSTBOX wraps MEOS C function nad_tposechain_stbox. +func NadTposechainSTBOX(temp *Temporal, box *STBox) (_r0 float64, _err error) { + C.meos_errno_reset() + _cret := C.nad_tposechain_stbox(temp._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil +} + + +// NadTposechainTposechain wraps MEOS C function nad_tposechain_tposechain. +func NadTposechainTposechain(temp1 *Temporal, temp2 *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() + _cret := C.nad_tposechain_tposechain(temp1._inner, temp2._inner) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil +} + + +// NaiTposechainGeo wraps MEOS C function nai_tposechain_geo. +func NaiTposechainGeo(temp *Temporal, gs *Geom) (_r0 *TInstant, _err error) { + C.meos_errno_reset() + _cret := C.nai_tposechain_geo(temp._inner, gs._inner) + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil +} + + +// NaiTposechainPosechain wraps MEOS C function nai_tposechain_posechain. +func NaiTposechainPosechain(temp *Temporal, pc unsafe.Pointer) (_r0 *TInstant, _err error) { + C.meos_errno_reset() + _cret := C.nai_tposechain_posechain(temp._inner, (*C.PoseChain)(unsafe.Pointer(pc))) + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil +} + + +// NaiTposechainTposechain wraps MEOS C function nai_tposechain_tposechain. +func NaiTposechainTposechain(temp1 *Temporal, temp2 *Temporal) (_r0 *TInstant, _err error) { + C.meos_errno_reset() + _cret := C.nai_tposechain_tposechain(temp1._inner, temp2._inner) + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil +} + + +// ShortestlineTposechainGeo wraps MEOS C function shortestline_tposechain_geo. +func ShortestlineTposechainGeo(temp *Temporal, gs *Geom) (_r0 *Geom, _err error) { + C.meos_errno_reset() + _cret := C.shortestline_tposechain_geo(temp._inner, gs._inner) + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil +} + + +// ShortestlineTposechainPosechain wraps MEOS C function shortestline_tposechain_posechain. +func ShortestlineTposechainPosechain(temp *Temporal, pc unsafe.Pointer) (_r0 *Geom, _err error) { + C.meos_errno_reset() + _cret := C.shortestline_tposechain_posechain(temp._inner, (*C.PoseChain)(unsafe.Pointer(pc))) + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil +} + + +// ShortestlineTposechainTposechain wraps MEOS C function shortestline_tposechain_tposechain. +func ShortestlineTposechainTposechain(temp1 *Temporal, temp2 *Temporal) (_r0 *Geom, _err error) { + C.meos_errno_reset() + _cret := C.shortestline_tposechain_tposechain(temp1._inner, temp2._inner) + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil +} + + // AlwaysEqPosechainTposechain wraps MEOS C function always_eq_posechain_tposechain. func AlwaysEqPosechainTposechain(posechain unsafe.Pointer, temp *Temporal) (_r0 int, _err error) { C.meos_errno_reset() diff --git a/functions/meos_meos_quadbin.go b/functions/meos_meos_quadbin.go index 2b787fb..3e0391a 100644 --- a/functions/meos_meos_quadbin.go +++ b/functions/meos_meos_quadbin.go @@ -1354,3 +1354,14 @@ func TquadbinCellToQuadkey(temp *Temporal) (_r0 *Temporal, _err error) { return &Temporal{_inner: _cret}, nil } + +// TquadbinGridDistance wraps MEOS C function tquadbin_grid_distance. +func TquadbinGridDistance(origin *Temporal, dest *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() + _cret := C.tquadbin_grid_distance(origin._inner, dest._inner) + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil +} + diff --git a/functions/meos_meos_raster.go b/functions/meos_meos_raster.go index f8ae8b9..3c5aa39 100644 --- a/functions/meos_meos_raster.go +++ b/functions/meos_meos_raster.go @@ -836,9 +836,9 @@ func RasterValueCount(rast unsafe.Pointer, band int, exclude_nodata bool, search // RasterSetValues wraps MEOS C function raster_set_values. -func RasterSetValues(rast unsafe.Pointer, band int, x int, y int, width int, height int, values unsafe.Pointer, nodata unsafe.Pointer, noset unsafe.Pointer, count int, keepnodata bool) (_r0 unsafe.Pointer, _err error) { +func RasterSetValues(rast unsafe.Pointer, band int, x int, y int, width int, height int, values unsafe.Pointer, nodata unsafe.Pointer, noset unsafe.Pointer, nosetwidth int, nosetheight int, count int, keepnodata bool) (_r0 unsafe.Pointer, _err error) { C.meos_errno_reset() - _cret := C.raster_set_values((*C.Raster)(unsafe.Pointer(rast)), C.int(band), C.int(x), C.int(y), C.int(width), C.int(height), (*C.double)(unsafe.Pointer(values)), (*C.bool)(unsafe.Pointer(nodata)), (*C.bool)(unsafe.Pointer(noset)), C.int(count), C.bool(keepnodata)) + _cret := C.raster_set_values((*C.Raster)(unsafe.Pointer(rast)), C.int(band), C.int(x), C.int(y), C.int(width), C.int(height), (*C.double)(unsafe.Pointer(values)), (*C.bool)(unsafe.Pointer(nodata)), (*C.bool)(unsafe.Pointer(noset)), C.int(nosetwidth), C.int(nosetheight), C.int(count), C.bool(keepnodata)) if _err = meosError(); _err != nil { return } diff --git a/functions/meos_meos_rgeo.go b/functions/meos_meos_rgeo.go index a84655c..f4253fa 100644 --- a/functions/meos_meos_rgeo.go +++ b/functions/meos_meos_rgeo.go @@ -476,6 +476,18 @@ func TrgeometryValueN(temp *Temporal, n int) (_r0 bool, _r1 *Geom, _err error) { } +// TrgeometryValueAtTimestamptz wraps MEOS C function trgeometry_value_at_timestamptz. +func TrgeometryValueAtTimestamptz(temp *Temporal, t int64, strict bool) (_r0 bool, _r1 *Geom, _err error) { + var _out_result *C.GSERIALIZED + C.meos_errno_reset() + _cret := C.trgeometry_value_at_timestamptz(temp._inner, C.TimestampTz(t), C.bool(strict), &_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Geom{_inner: _out_result}, nil +} + + // TrgeometryTraversedArea wraps MEOS C function trgeometry_traversed_area. func TrgeometryTraversedArea(temp *Temporal, unary_union bool) (_r0 *Geom, _err error) { C.meos_errno_reset() diff --git a/functions/meos_meos_s2cell.go b/functions/meos_meos_s2cell.go index fa04a15..01a8276 100644 --- a/functions/meos_meos_s2cell.go +++ b/functions/meos_meos_s2cell.go @@ -1362,3 +1362,14 @@ func Ts2cellCellToToken(temp *Temporal) (_r0 *Temporal, _err error) { return &Temporal{_inner: _cret}, nil } + +// Ts2cellGridDistance wraps MEOS C function ts2cell_grid_distance. +func Ts2cellGridDistance(origin *Temporal, dest *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() + _cret := C.ts2cell_grid_distance(origin._inner, dest._inner) + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil +} + diff --git a/functions/meos_pg_time.go b/functions/meos_pg_time.go index ca7df7a..1f4f87b 100644 --- a/functions/meos_pg_time.go +++ b/functions/meos_pg_time.go @@ -183,13 +183,13 @@ func PlusTimetzInterval(timetz unsafe.Pointer, interv *Interval) (_r0 unsafe.Poi // TimeCmp wraps MEOS C function time_cmp. -func TimeCmp(time1 int64, time2 int64) (_r0 int, _err error) { +func TimeCmp(time1 int64, time2 int64) (_r0 int32, _err error) { C.meos_errno_reset() _cret := C.time_cmp(C.TimeADT(time1), C.TimeADT(time2)) if _err = meosError(); _err != nil { return } - return int(_cret), nil + return int32(_cret), nil } diff --git a/functions/meos_pg_timestamp.go b/functions/meos_pg_timestamp.go index 1488197..15c404b 100644 --- a/functions/meos_pg_timestamp.go +++ b/functions/meos_pg_timestamp.go @@ -662,13 +662,13 @@ func TimestamptzBin(tstz int64, stride *Interval, origin int64) (_r0 int64, _err // TimestamptzHash wraps MEOS C function timestamptz_hash. -func TimestamptzHash(tstz int64) (_r0 int32, _err error) { +func TimestamptzHash(tstz int64) (_r0 uint32, _err error) { C.meos_errno_reset() _cret := C.timestamptz_hash(C.TimestampTz(tstz)) if _err = meosError(); _err != nil { return } - return int32(_cret), nil + return uint32(_cret), nil } diff --git a/tools/objectgen.py b/tools/objectgen.py index 2cbe4bd..dff369c 100644 --- a/tools/objectgen.py +++ b/tools/objectgen.py @@ -294,6 +294,13 @@ def method_for(self, cls: str, entry: dict) -> str | None: args.insert(0, f"functions.{handle}FromPointer(x.Pointer())") name = pascal(oo) if recv is not None else cls + pascal(oo) + # A method may not share the name of the struct its class embeds, the + # field Go gives that parent (JsonbSet embeds Set, and jsonbset_set reads + # `set`), so such a method takes the name of its SQL function, which + # carries the type as the SQL dialect writes it (jsonbsetSet), spelled as + # #pascal spells every method. + if recv is not None and name == self.m.parent.get(cls): + name = pascal(f.get("sqlfn") or cls[:1].lower() + cls[1:] + name) # 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 diff --git a/types/cbuffer.go b/types/cbuffer.go index 9c7aa92..91975b9 100644 --- a/types/cbuffer.go +++ b/types/cbuffer.go @@ -41,8 +41,8 @@ func (x *Cbuffer) AsEWKT(maxdd int) (string, error) { return _r0, nil } -// AsHEXEWKB is MEOS cbuffer_as_hexewkb. -func (x *Cbuffer) AsHEXEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { +// AsHexEWKB is MEOS cbuffer_as_hexewkb. +func (x *Cbuffer) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { _r0, _err := functions.CbufferAsHexewkb(functions.CbufferFromPointer(x.Pointer()), variant, size_out) if _err != nil { return "", _err @@ -50,8 +50,8 @@ func (x *Cbuffer) AsHEXEWKB(variant uint8, size_out unsafe.Pointer) (string, err return _r0, nil } -// AsHEXWKB is MEOS cbuffer_as_hexwkb. -func (x *Cbuffer) AsHEXWKB(variant uint8, size_out unsafe.Pointer) (string, error) { +// 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 @@ -77,8 +77,8 @@ func (x *Cbuffer) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, return _r0, nil } -// CbufferFromHEXWKB is MEOS cbuffer_from_hexwkb. -func CbufferFromHEXWKB(hexwkb string) (*Cbuffer, error) { +// CbufferFromHexWKB is MEOS cbuffer_from_hexwkb. +func CbufferFromHexWKB(hexwkb string) (*Cbuffer, error) { _r0, _err := functions.CbufferFromHexwkb(hexwkb) if _err != nil { return nil, _err diff --git a/types/cbufferset.go b/types/cbufferset.go index f17d6dd..7f316f4 100644 --- a/types/cbufferset.go +++ b/types/cbufferset.go @@ -9,7 +9,7 @@ import ( ) type CbufferSet struct { - Set + SpatialSet } // CbufferSetFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/geo.go b/types/geo.go index 16dae43..3c29aae 100644 --- a/types/geo.go +++ b/types/geo.go @@ -41,8 +41,8 @@ func GeoAsEWKT(gs *TRGeometrySeqSet, precision int) (string, error) { return _r0, nil } -// GeoAsGEOJSON is MEOS geo_as_geojson. -func GeoAsGEOJSON(gs *TRGeometrySeqSet, option int, precision int, srs *string) (string, error) { +// 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 @@ -50,8 +50,8 @@ func GeoAsGEOJSON(gs *TRGeometrySeqSet, option int, precision int, srs *string) return _r0, nil } -// GeoAsHEXEWKB is MEOS geo_as_hexewkb. -func GeoAsHEXEWKB(gs *TRGeometrySeqSet, endian *string) (string, error) { +// 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 @@ -77,8 +77,8 @@ func GeoFromEWKB(wkb unsafe.Pointer, wkb_size uint, srid int32) (*TRGeometrySeqS return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil } -// GeoFromGEOJSON is MEOS geo_from_geojson. -func GeoFromGEOJSON(geojson string) (*TRGeometrySeqSet, error) { +// GeoFromGeoJSON is MEOS geo_from_geojson. +func GeoFromGeoJSON(geojson string) (*TRGeometrySeqSet, error) { _r0, _err := functions.GeoFromGeojson(geojson) if _err != nil { return nil, _err @@ -267,8 +267,17 @@ func GeoScale(gs *TRGeometrySeqSet, xfactor float64, yfactor float64, zfactor fl } // GeoScaleGeo is MEOS geo_scale_geo. -func GeoScaleGeo(gs *TRGeometrySeqSet, scale *TRGeometrySeqSet, sorigin *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeoScaleGeo(functions.GeomFromPointer(gs.Pointer()), functions.GeomFromPointer(scale.Pointer()), functions.GeomFromPointer(sorigin.Pointer())) +func GeoScaleGeo(gs *TRGeometrySeqSet, scale *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeoScaleGeo(functions.GeomFromPointer(gs.Pointer()), functions.GeomFromPointer(scale.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// GeoScaleGeoOrigin is MEOS geo_scale_geo_origin. +func GeoScaleGeoOrigin(gs *TRGeometrySeqSet, scale *TRGeometrySeqSet, sorigin *TRGeometrySeqSet) (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeoScaleGeoOrigin(functions.GeomFromPointer(gs.Pointer()), functions.GeomFromPointer(scale.Pointer()), functions.GeomFromPointer(sorigin.Pointer())) if _err != nil { return nil, _err } diff --git a/types/geography.go b/types/geography.go index 3f05449..cace3dc 100644 --- a/types/geography.go +++ b/types/geography.go @@ -23,8 +23,8 @@ func GeographyFromPointer(p unsafe.Pointer) *Geography { return v } -// GeographyFromHEXEWKB is MEOS geog_from_hexewkb. -func GeographyFromHEXEWKB(hexwkb string) (*TRGeometrySeqSet, error) { +// GeographyFromHexEWKB is MEOS geog_from_hexewkb. +func GeographyFromHexEWKB(hexwkb string) (*TRGeometrySeqSet, error) { _r0, _err := functions.GeogFromHexewkb(hexwkb) if _err != nil { return nil, _err diff --git a/types/geogset.go b/types/geogset.go index f56730e..594dd47 100644 --- a/types/geogset.go +++ b/types/geogset.go @@ -9,7 +9,7 @@ import ( ) type GeogSet struct { - Set + GeoSet } // GeogSetFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/geometry.go b/types/geometry.go index 24f1f46..7b39cfa 100644 --- a/types/geometry.go +++ b/types/geometry.go @@ -23,8 +23,8 @@ func GeometryFromPointer(p unsafe.Pointer) *Geometry { return v } -// GeometryFromHEXEWKB is MEOS geom_from_hexewkb. -func GeometryFromHEXEWKB(hexwkb string) (*TRGeometrySeqSet, error) { +// GeometryFromHexEWKB is MEOS geom_from_hexewkb. +func GeometryFromHexEWKB(hexwkb string) (*TRGeometrySeqSet, error) { _r0, _err := functions.GeomFromHexewkb(hexwkb) if _err != nil { return nil, _err diff --git a/types/geomset.go b/types/geomset.go index b0ca24e..5467d68 100644 --- a/types/geomset.go +++ b/types/geomset.go @@ -9,7 +9,7 @@ import ( ) type GeomSet struct { - Set + GeoSet } // GeomSetFromPointer wraps a MEOS pointer, answering nil for nil so an @@ -31,60 +31,3 @@ func GeomSetIn(str string) (*Set, error) { } 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 -} - -// ToGeo is MEOS geoset_to_geo. -func (x *GeomSet) ToGeo() (*TRGeometrySeqSet, error) { - _r0, _err := functions.GeosetToGeo(functions.SetFromPointer(x.Pointer())) - if _err != nil { - return nil, _err - } - return TRGeometrySeqSetFromPointer(_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/geoset.go b/types/geoset.go new file mode 100644 index 0000000..e083748 --- /dev/null +++ b/types/geoset.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 GeoSet struct { + SpatialSet +} + +// GeoSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func GeoSetFromPointer(p unsafe.Pointer) *GeoSet { + if p == nil { + return nil + } + v := &GeoSet{} + v.ptr = p + return v +} + +// GeoSetMake is MEOS geoset_make. +func GeoSetMake(values unsafe.Pointer, count int) (*Set, error) { + _r0, _err := functions.GeosetMake(values, count) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// ToGeo is MEOS geoset_to_geo. +func (x *GeoSet) ToGeo() (*TRGeometrySeqSet, error) { + _r0, _err := functions.GeosetToGeo(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS geoset_end_value. +func (x *GeoSet) 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 *GeoSet) 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 *GeoSet) 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 *GeoSet) 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/h3indexset.go b/types/h3indexset.go new file mode 100644 index 0000000..86a04f4 --- /dev/null +++ b/types/h3indexset.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 H3IndexSet struct { + SpatialSet +} + +// H3IndexSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func H3IndexSetFromPointer(p unsafe.Pointer) *H3IndexSet { + if p == nil { + return nil + } + v := &H3IndexSet{} + v.ptr = p + return v +} + +// H3IndexSetIn is MEOS h3indexset_in. +func H3IndexSetIn(str string) (*Set, error) { + _r0, _err := functions.H3indexsetIn(str) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS h3indexset_out. +func (x *H3IndexSet) Out() (string, error) { + _r0, _err := functions.H3indexsetOut(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// H3IndexSetMake is MEOS h3indexset_make. +func H3IndexSetMake(values unsafe.Pointer, count int) (*Set, error) { + _r0, _err := functions.H3indexsetMake(values, count) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS h3indexset_end_value. +func (x *H3IndexSet) EndValue() (uint64, error) { + _r0, _err := functions.H3indexsetEndValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// StartValue is MEOS h3indexset_start_value. +func (x *H3IndexSet) StartValue() (uint64, error) { + _r0, _err := functions.H3indexsetStartValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ValueN is MEOS h3indexset_value_n. +func (x *H3IndexSet) ValueN(n int) (uint64, bool, error) { + _found, _value, _err := functions.H3indexsetValueN(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 h3indexset_values. +func (x *H3IndexSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.H3indexsetValues(functions.SetFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// GridDisk is MEOS h3indexset_grid_disk. +func (x *H3IndexSet) GridDisk(k int) (*Set, error) { + _r0, _err := functions.H3indexsetGridDisk(functions.SetFromPointer(x.Pointer()), k) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// CoverCells is MEOS h3indexset_cover_cells. +func (x *H3IndexSet) CoverCells(resolution int32) (*Set, error) { + _r0, _err := functions.H3indexsetCoverCells(functions.SetFromPointer(x.Pointer()), resolution) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} diff --git a/types/jsonbset.go b/types/jsonbset.go new file mode 100644 index 0000000..284c6d0 --- /dev/null +++ b/types/jsonbset.go @@ -0,0 +1,333 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type JsonbSet struct { + Set +} + +// JsonbSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func JsonbSetFromPointer(p unsafe.Pointer) *JsonbSet { + if p == nil { + return nil + } + v := &JsonbSet{} + v.ptr = p + return v +} + +// JsonbSetIn is MEOS jsonbset_in. +func JsonbSetIn(str string) (*Set, error) { + _r0, _err := functions.JsonbsetIn(str) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS jsonbset_out. +func (x *JsonbSet) Out() (string, error) { + _r0, _err := functions.JsonbsetOut(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// JsonbSetMake is MEOS jsonbset_make. +func JsonbSetMake(values unsafe.Pointer, count int) (*Set, error) { + _r0, _err := functions.JsonbsetMake(values, count) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// ToTextset is MEOS jsonbset_to_textset. +func (x *JsonbSet) ToTextset() (*Set, error) { + _r0, _err := functions.JsonbsetToTextset(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS jsonbset_end_value. +func (x *JsonbSet) EndValue() (*Jsonb, error) { + _r0, _err := functions.JsonbsetEndValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// StartValue is MEOS jsonbset_start_value. +func (x *JsonbSet) StartValue() (*Jsonb, error) { + _r0, _err := functions.JsonbsetStartValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return JsonbFromPointer(_r0.Pointer()), nil +} + +// ValueN is MEOS jsonbset_value_n. +func (x *JsonbSet) ValueN(n int) (*Jsonb, bool, error) { + _found, _value, _err := functions.JsonbsetValueN(functions.SetFromPointer(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 jsonbset_values. +func (x *JsonbSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.JsonbsetValues(functions.SetFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// ArrayLength is MEOS jsonbset_array_length. +func (x *JsonbSet) ArrayLength() (*Set, error) { + _r0, _err := functions.JsonbsetArrayLength(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// ObjectField is MEOS jsonbset_object_field. +func (x *JsonbSet) ObjectField(key string, null_handle functions.NullHandleType) (*Set, error) { + _r0, _err := functions.JsonbsetObjectField(functions.SetFromPointer(x.Pointer()), key, null_handle) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// ObjectFieldText is MEOS jsonbset_object_field_text. +func (x *JsonbSet) ObjectFieldText(key string, null_handle functions.NullHandleType) (*Set, error) { + _r0, _err := functions.JsonbsetObjectFieldText(functions.SetFromPointer(x.Pointer()), key, null_handle) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// ArrayElement is MEOS jsonbset_array_element. +func (x *JsonbSet) ArrayElement(idx int, null_handle functions.NullHandleType) (*Set, error) { + _r0, _err := functions.JsonbsetArrayElement(functions.SetFromPointer(x.Pointer()), idx, null_handle) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// ArrayElementText is MEOS jsonbset_array_element_text. +func (x *JsonbSet) ArrayElementText(idx int, null_handle functions.NullHandleType) (*Set, error) { + _r0, _err := functions.JsonbsetArrayElementText(functions.SetFromPointer(x.Pointer()), idx, null_handle) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// DeleteIndex is MEOS jsonbset_delete_index. +func (x *JsonbSet) DeleteIndex(idx int) (*Set, error) { + _r0, _err := functions.JsonbsetDeleteIndex(functions.SetFromPointer(x.Pointer()), idx) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Delete is MEOS jsonbset_delete. +func (x *JsonbSet) Delete(key string) (*Set, error) { + _r0, _err := functions.JsonbsetDelete(functions.SetFromPointer(x.Pointer()), key) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// DeleteArray is MEOS jsonbset_delete_array. +func (x *JsonbSet) DeleteArray(keys unsafe.Pointer, count int) (*Set, error) { + _r0, _err := functions.JsonbsetDeleteArray(functions.SetFromPointer(x.Pointer()), keys, count) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Exists is MEOS jsonbset_exists. +func (x *JsonbSet) Exists(key string, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.JsonbsetExists(functions.SetFromPointer(x.Pointer()), key, count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// ExistsArray is MEOS jsonbset_exists_array. +func (x *JsonbSet) ExistsArray(keys unsafe.Pointer, count int, any bool, rescount unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.JsonbsetExistsArray(functions.SetFromPointer(x.Pointer()), keys, count, any, rescount) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// JsonbsetSet is MEOS jsonbset_set. +func (x *JsonbSet) JsonbsetSet(keys unsafe.Pointer, count int, newjb *Jsonb, create bool, null_handle string, lax bool) (*Set, error) { + _r0, _err := functions.JsonbsetSet(functions.SetFromPointer(x.Pointer()), keys, count, functions.JsonbFromPointer(newjb.Pointer()), create, null_handle, lax) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// ToAlphanumset is MEOS jsonbset_to_alphanumset. +func (x *JsonbSet) ToAlphanumset(key string, settype functions.MeosType, null_handle functions.NullHandleType) (*Set, error) { + _r0, _err := functions.JsonbsetToAlphanumset(functions.SetFromPointer(x.Pointer()), key, settype, null_handle) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// ToIntset is MEOS jsonbset_to_intset. +func (x *JsonbSet) ToIntset(key string, null_handle functions.NullHandleType) (*Set, error) { + _r0, _err := functions.JsonbsetToIntset(functions.SetFromPointer(x.Pointer()), key, null_handle) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// ToBigintset is MEOS jsonbset_to_bigintset. +func (x *JsonbSet) ToBigintset(key string, null_handle functions.NullHandleType) (*Set, error) { + _r0, _err := functions.JsonbsetToBigintset(functions.SetFromPointer(x.Pointer()), key, null_handle) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// ToFloatset is MEOS jsonbset_to_floatset. +func (x *JsonbSet) ToFloatset(key string, null_handle functions.NullHandleType) (*Set, error) { + _r0, _err := functions.JsonbsetToFloatset(functions.SetFromPointer(x.Pointer()), key, null_handle) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// ToTextsetKey is MEOS jsonbset_to_textset_key. +func (x *JsonbSet) ToTextsetKey(key string, null_handle functions.NullHandleType) (*Set, error) { + _r0, _err := functions.JsonbsetToTextsetKey(functions.SetFromPointer(x.Pointer()), key, null_handle) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// StripNulls is MEOS jsonbset_strip_nulls. +func (x *JsonbSet) StripNulls(strip_in_arrays bool) (*Set, error) { + _r0, _err := functions.JsonbsetStripNulls(functions.SetFromPointer(x.Pointer()), strip_in_arrays) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Pretty is MEOS jsonbset_pretty. +func (x *JsonbSet) Pretty() (*Set, error) { + _r0, _err := functions.JsonbsetPretty(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// DeletePath is MEOS jsonbset_delete_path. +func (x *JsonbSet) DeletePath(path_elems unsafe.Pointer, path_len int) (*Set, error) { + _r0, _err := functions.JsonbsetDeletePath(functions.SetFromPointer(x.Pointer()), path_elems, path_len) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// ExtractPath is MEOS jsonbset_extract_path. +func (x *JsonbSet) ExtractPath(path_elems unsafe.Pointer, path_len int, null_handle functions.NullHandleType) (*Set, error) { + _r0, _err := functions.JsonbsetExtractPath(functions.SetFromPointer(x.Pointer()), path_elems, path_len, null_handle) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// ExtractPathText is MEOS jsonbset_extract_path_text. +func (x *JsonbSet) ExtractPathText(path_elems unsafe.Pointer, path_len int, null_handle functions.NullHandleType) (*Set, error) { + _r0, _err := functions.JsonbsetExtractPathText(functions.SetFromPointer(x.Pointer()), path_elems, path_len, null_handle) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Insert is MEOS jsonbset_insert. +func (x *JsonbSet) Insert(path_elems unsafe.Pointer, path_len int, newjb *Jsonb, after bool) (*Set, error) { + _r0, _err := functions.JsonbsetInsert(functions.SetFromPointer(x.Pointer()), path_elems, path_len, functions.JsonbFromPointer(newjb.Pointer()), after) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// PathExists is MEOS jsonbset_path_exists. +func (x *JsonbSet) PathExists(jp *JsonPath, vars *Jsonb, silent bool, tz bool, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.JsonbsetPathExists(functions.SetFromPointer(x.Pointer()), functions.JsonPathFromPointer(jp.Pointer()), functions.JsonbFromPointer(vars.Pointer()), silent, tz, count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// PathMatch is MEOS jsonbset_path_match. +func (x *JsonbSet) PathMatch(jp *JsonPath, vars *Jsonb, silent bool, tz bool, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.JsonbsetPathMatch(functions.SetFromPointer(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 jsonbset_path_query_array. +func (x *JsonbSet) PathQueryArray(jp *JsonPath, vars *Jsonb, silent bool, tz bool) (*Set, error) { + _r0, _err := functions.JsonbsetPathQueryArray(functions.SetFromPointer(x.Pointer()), functions.JsonPathFromPointer(jp.Pointer()), functions.JsonbFromPointer(vars.Pointer()), silent, tz) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// PathQueryFirst is MEOS jsonbset_path_query_first. +func (x *JsonbSet) PathQueryFirst(jp *JsonPath, vars *Jsonb, silent bool, tz bool) (*Set, error) { + _r0, _err := functions.JsonbsetPathQueryFirst(functions.SetFromPointer(x.Pointer()), functions.JsonPathFromPointer(jp.Pointer()), functions.JsonbFromPointer(vars.Pointer()), silent, tz) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} diff --git a/types/npoint.go b/types/npoint.go index ac1b446..d190f42 100644 --- a/types/npoint.go +++ b/types/npoint.go @@ -41,8 +41,8 @@ func (x *Npoint) AsEWKT(maxdd int) (string, error) { return _r0, nil } -// AsHEXEWKB is MEOS npoint_as_hexewkb. -func (x *Npoint) AsHEXEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { +// AsHexEWKB is MEOS npoint_as_hexewkb. +func (x *Npoint) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { _r0, _err := functions.NpointAsHexewkb(functions.NpointFromPointer(x.Pointer()), variant, size_out) if _err != nil { return "", _err @@ -50,8 +50,8 @@ func (x *Npoint) AsHEXEWKB(variant uint8, size_out unsafe.Pointer) (string, erro return _r0, nil } -// AsHEXWKB is MEOS npoint_as_hexwkb. -func (x *Npoint) AsHEXWKB(variant uint8, size_out unsafe.Pointer) (string, error) { +// 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 @@ -77,8 +77,8 @@ func (x *Npoint) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, return _r0, nil } -// NpointFromHEXWKB is MEOS npoint_from_hexwkb. -func NpointFromHEXWKB(hexwkb string) (*Npoint, error) { +// NpointFromHexWKB is MEOS npoint_from_hexwkb. +func NpointFromHexWKB(hexwkb string) (*Npoint, error) { _r0, _err := functions.NpointFromHexwkb(hexwkb) if _err != nil { return nil, _err diff --git a/types/npointset.go b/types/npointset.go index 6421dc7..f89dfa7 100644 --- a/types/npointset.go +++ b/types/npointset.go @@ -9,7 +9,7 @@ import ( ) type NpointSet struct { - Set + SpatialSet } // NpointSetFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/nsegment.go b/types/nsegment.go index 5f91a02..b01b33b 100644 --- a/types/nsegment.go +++ b/types/nsegment.go @@ -23,8 +23,8 @@ func NsegmentFromPointer(p unsafe.Pointer) *Nsegment { return v } -// AsHEXEWKB is MEOS nsegment_as_hexewkb. -func (x *Nsegment) AsHEXEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { +// AsHexEWKB is MEOS nsegment_as_hexewkb. +func (x *Nsegment) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { _r0, _err := functions.NsegmentAsHexewkb(functions.NsegmentFromPointer(x.Pointer()), variant, size_out) if _err != nil { return "", _err @@ -32,8 +32,8 @@ func (x *Nsegment) AsHEXEWKB(variant uint8, size_out unsafe.Pointer) (string, er return _r0, nil } -// AsHEXWKB is MEOS nsegment_as_hexwkb. -func (x *Nsegment) AsHEXWKB(variant uint8, size_out unsafe.Pointer) (string, error) { +// AsHexWKB is MEOS nsegment_as_hexwkb. +func (x *Nsegment) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) { _r0, _err := functions.NsegmentAsHexwkb(functions.NsegmentFromPointer(x.Pointer()), variant, size_out) if _err != nil { return "", _err @@ -50,8 +50,8 @@ func (x *Nsegment) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer return _r0, nil } -// NsegmentFromHEXWKB is MEOS nsegment_from_hexwkb. -func NsegmentFromHEXWKB(hexwkb string) (*Nsegment, error) { +// NsegmentFromHexWKB is MEOS nsegment_from_hexwkb. +func NsegmentFromHexWKB(hexwkb string) (*Nsegment, error) { _r0, _err := functions.NsegmentFromHexwkb(hexwkb) if _err != nil { return nil, _err diff --git a/types/pcpatch.go b/types/pcpatch.go index 44f8d79..ace04cf 100644 --- a/types/pcpatch.go +++ b/types/pcpatch.go @@ -41,8 +41,8 @@ func (x *Pcpatch) HexOut(maxdd int) (string, error) { return _r0, nil } -// PcpatchFromHEXWKB is MEOS pcpatch_from_hexwkb. -func PcpatchFromHEXWKB(hexwkb string) (*Pcpatch, error) { +// PcpatchFromHexWKB is MEOS pcpatch_from_hexwkb. +func PcpatchFromHexWKB(hexwkb string) (*Pcpatch, error) { _r0, _err := functions.PcpatchFromHexwkb(hexwkb) if _err != nil { return nil, _err @@ -50,8 +50,8 @@ func PcpatchFromHEXWKB(hexwkb string) (*Pcpatch, error) { return PcpatchFromPointer(_r0.Pointer()), nil } -// AsHEXWKB is MEOS pcpatch_as_hexwkb. -func (x *Pcpatch) AsHEXWKB() (string, error) { +// 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 diff --git a/types/pcpatchset.go b/types/pcpatchset.go new file mode 100644 index 0000000..70e2cda --- /dev/null +++ b/types/pcpatchset.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 PcpatchSet struct { + SpatialSet +} + +// PcpatchSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func PcpatchSetFromPointer(p unsafe.Pointer) *PcpatchSet { + if p == nil { + return nil + } + v := &PcpatchSet{} + v.ptr = p + return v +} + +// PcpatchSetIn is MEOS pcpatchset_in. +func PcpatchSetIn(str string) (*Set, error) { + _r0, _err := functions.PcpatchsetIn(str) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS pcpatchset_out. +func (x *PcpatchSet) Out(maxdd int) (string, error) { + _r0, _err := functions.PcpatchsetOut(functions.SetFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// PcpatchSetMake is MEOS pcpatchset_make. +func PcpatchSetMake(values unsafe.Pointer, count int) (*Set, error) { + _r0, _err := functions.PcpatchsetMake(values, count) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// StartValue is MEOS pcpatchset_start_value. +func (x *PcpatchSet) StartValue() (*Pcpatch, error) { + _r0, _err := functions.PcpatchsetStartValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return PcpatchFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS pcpatchset_end_value. +func (x *PcpatchSet) EndValue() (*Pcpatch, error) { + _r0, _err := functions.PcpatchsetEndValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return PcpatchFromPointer(_r0.Pointer()), nil +} + +// ValueN is MEOS pcpatchset_value_n. +func (x *PcpatchSet) ValueN(n int) (*Pcpatch, bool, error) { + _found, _value, _err := functions.PcpatchsetValueN(functions.SetFromPointer(x.Pointer()), n) + if _err != nil { + return nil, false, _err + } + if !_found { + return nil, false, nil + } + return PcpatchFromPointer(_value.Pointer()), true, nil +} + +// Values is MEOS pcpatchset_values. +func (x *PcpatchSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.PcpatchsetValues(functions.SetFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} diff --git a/types/pcpoint.go b/types/pcpoint.go index fdd4d1b..87027fe 100644 --- a/types/pcpoint.go +++ b/types/pcpoint.go @@ -41,8 +41,8 @@ func (x *Pcpoint) HexOut(maxdd int) (string, error) { return _r0, nil } -// PcpointFromHEXWKB is MEOS pcpoint_from_hexwkb. -func PcpointFromHEXWKB(hexwkb string) (*Pcpoint, error) { +// PcpointFromHexWKB is MEOS pcpoint_from_hexwkb. +func PcpointFromHexWKB(hexwkb string) (*Pcpoint, error) { _r0, _err := functions.PcpointFromHexwkb(hexwkb) if _err != nil { return nil, _err @@ -50,8 +50,8 @@ func PcpointFromHEXWKB(hexwkb string) (*Pcpoint, error) { return PcpointFromPointer(_r0.Pointer()), nil } -// AsHEXWKB is MEOS pcpoint_as_hexwkb. -func (x *Pcpoint) AsHEXWKB() (string, error) { +// 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 diff --git a/types/pcpointset.go b/types/pcpointset.go new file mode 100644 index 0000000..6ec2f85 --- /dev/null +++ b/types/pcpointset.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 PcpointSet struct { + SpatialSet +} + +// PcpointSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func PcpointSetFromPointer(p unsafe.Pointer) *PcpointSet { + if p == nil { + return nil + } + v := &PcpointSet{} + v.ptr = p + return v +} + +// PcpointSetIn is MEOS pcpointset_in. +func PcpointSetIn(str string) (*Set, error) { + _r0, _err := functions.PcpointsetIn(str) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS pcpointset_out. +func (x *PcpointSet) Out(maxdd int) (string, error) { + _r0, _err := functions.PcpointsetOut(functions.SetFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// PcpointSetMake is MEOS pcpointset_make. +func PcpointSetMake(values unsafe.Pointer, count int) (*Set, error) { + _r0, _err := functions.PcpointsetMake(values, count) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// StartValue is MEOS pcpointset_start_value. +func (x *PcpointSet) StartValue() (*Pcpoint, error) { + _r0, _err := functions.PcpointsetStartValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return PcpointFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS pcpointset_end_value. +func (x *PcpointSet) EndValue() (*Pcpoint, error) { + _r0, _err := functions.PcpointsetEndValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return PcpointFromPointer(_r0.Pointer()), nil +} + +// ValueN is MEOS pcpointset_value_n. +func (x *PcpointSet) ValueN(n int) (*Pcpoint, bool, error) { + _found, _value, _err := functions.PcpointsetValueN(functions.SetFromPointer(x.Pointer()), n) + if _err != nil { + return nil, false, _err + } + if !_found { + return nil, false, nil + } + return PcpointFromPointer(_value.Pointer()), true, nil +} + +// Values is MEOS pcpointset_values. +func (x *PcpointSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.PcpointsetValues(functions.SetFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} diff --git a/types/pose.go b/types/pose.go index 468f3a4..afae13b 100644 --- a/types/pose.go +++ b/types/pose.go @@ -41,8 +41,8 @@ func (x *Pose) AsEWKT(maxdd int) (string, error) { return _r0, nil } -// AsHEXEWKB is MEOS pose_as_hexewkb. -func (x *Pose) AsHEXEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { +// AsHexEWKB is MEOS pose_as_hexewkb. +func (x *Pose) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { _r0, _err := functions.PoseAsHexewkb(functions.PoseFromPointer(x.Pointer()), variant, size_out) if _err != nil { return "", _err @@ -50,8 +50,8 @@ func (x *Pose) AsHEXEWKB(variant uint8, size_out unsafe.Pointer) (string, error) return _r0, nil } -// AsHEXWKB is MEOS pose_as_hexwkb. -func (x *Pose) AsHEXWKB(variant uint8, size_out unsafe.Pointer) (string, error) { +// AsHexWKB is MEOS pose_as_hexwkb. +func (x *Pose) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) { _r0, _err := functions.PoseAsHexwkb(functions.PoseFromPointer(x.Pointer()), variant, size_out) if _err != nil { return "", _err @@ -86,8 +86,8 @@ func PoseFromWKB(wkb unsafe.Pointer, size uint) (*Pose, error) { return PoseFromPointer(_r0.Pointer()), nil } -// PoseFromHEXWKB is MEOS pose_from_hexwkb. -func PoseFromHEXWKB(hexwkb string) (*Pose, error) { +// PoseFromHexWKB is MEOS pose_from_hexwkb. +func PoseFromHexWKB(hexwkb string) (*Pose, error) { _r0, _err := functions.PoseFromHexwkb(hexwkb) if _err != nil { return nil, _err diff --git a/types/posechain.go b/types/posechain.go index d7ecc44..e318e45 100644 --- a/types/posechain.go +++ b/types/posechain.go @@ -77,8 +77,8 @@ func PoseChainAsWKB(pc unsafe.Pointer, variant uint8, size_out unsafe.Pointer) ( return _r0, nil } -// PoseChainAsHEXEWKB is MEOS posechain_as_hexewkb. -func PoseChainAsHEXEWKB(pc unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (string, error) { +// PoseChainAsHexEWKB is MEOS posechain_as_hexewkb. +func PoseChainAsHexEWKB(pc unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (string, error) { _r0, _err := functions.PosechainAsHexewkb(pc, variant, size_out) if _err != nil { return "", _err @@ -86,8 +86,8 @@ func PoseChainAsHEXEWKB(pc unsafe.Pointer, variant uint8, size_out unsafe.Pointe return _r0, nil } -// PoseChainAsHEXWKB is MEOS posechain_as_hexwkb. -func PoseChainAsHEXWKB(pc unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (string, error) { +// 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 @@ -104,8 +104,8 @@ func PoseChainFromWKB(wkb unsafe.Pointer, size uint) (unsafe.Pointer, error) { return _r0, nil } -// PoseChainFromHEXWKB is MEOS posechain_from_hexwkb. -func PoseChainFromHEXWKB(hexwkb string) (unsafe.Pointer, error) { +// PoseChainFromHexWKB is MEOS posechain_from_hexwkb. +func PoseChainFromHexWKB(hexwkb string) (unsafe.Pointer, error) { _r0, _err := functions.PosechainFromHexwkb(hexwkb) if _err != nil { return nil, _err diff --git a/types/posechainset.go b/types/posechainset.go new file mode 100644 index 0000000..0ccb5b9 --- /dev/null +++ b/types/posechainset.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 PoseChainSet struct { + SpatialSet +} + +// PoseChainSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func PoseChainSetFromPointer(p unsafe.Pointer) *PoseChainSet { + if p == nil { + return nil + } + v := &PoseChainSet{} + v.ptr = p + return v +} + +// PoseChainSetIn is MEOS posechainset_in. +func PoseChainSetIn(str string) (*Set, error) { + _r0, _err := functions.PosechainsetIn(str) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS posechainset_out. +func (x *PoseChainSet) Out(maxdd int) (string, error) { + _r0, _err := functions.PosechainsetOut(functions.SetFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// PoseChainSetMake is MEOS posechainset_make. +func PoseChainSetMake(values unsafe.Pointer, count int) (*Set, error) { + _r0, _err := functions.PosechainsetMake(values, count) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS posechainset_end_value. +func (x *PoseChainSet) EndValue() (unsafe.Pointer, error) { + _r0, _err := functions.PosechainsetEndValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// StartValue is MEOS posechainset_start_value. +func (x *PoseChainSet) StartValue() (unsafe.Pointer, error) { + _r0, _err := functions.PosechainsetStartValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Values is MEOS posechainset_values. +func (x *PoseChainSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.PosechainsetValues(functions.SetFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} diff --git a/types/poseset.go b/types/poseset.go index 98d99a5..d642a22 100644 --- a/types/poseset.go +++ b/types/poseset.go @@ -9,7 +9,7 @@ import ( ) type PoseSet struct { - Set + SpatialSet } // PoseSetFromPointer wraps a MEOS pointer, answering nil for nil so an diff --git a/types/quadbinset.go b/types/quadbinset.go new file mode 100644 index 0000000..246c775 --- /dev/null +++ b/types/quadbinset.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 QuadbinSet struct { + SpatialSet +} + +// QuadbinSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func QuadbinSetFromPointer(p unsafe.Pointer) *QuadbinSet { + if p == nil { + return nil + } + v := &QuadbinSet{} + v.ptr = p + return v +} + +// GridDisk is MEOS quadbinset_grid_disk. +func (x *QuadbinSet) GridDisk(k int) (*Set, error) { + _r0, _err := functions.QuadbinsetGridDisk(functions.SetFromPointer(x.Pointer()), k) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// CompactCells is MEOS quadbinset_compact_cells. +func (x *QuadbinSet) CompactCells() (*Set, error) { + _r0, _err := functions.QuadbinsetCompactCells(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// UncompactCells is MEOS quadbinset_uncompact_cells. +func (x *QuadbinSet) UncompactCells(resolution int) (*Set, error) { + _r0, _err := functions.QuadbinsetUncompactCells(functions.SetFromPointer(x.Pointer()), resolution) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// CoverCells is MEOS quadbinset_cover_cells. +func (x *QuadbinSet) CoverCells(resolution int) (*Set, error) { + _r0, _err := functions.QuadbinsetCoverCells(functions.SetFromPointer(x.Pointer()), resolution) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// QuadbinSetIn is MEOS quadbinset_in. +func QuadbinSetIn(str string) (*Set, error) { + _r0, _err := functions.QuadbinsetIn(str) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS quadbinset_out. +func (x *QuadbinSet) Out() (string, error) { + _r0, _err := functions.QuadbinsetOut(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// QuadbinSetMake is MEOS quadbinset_make. +func QuadbinSetMake(values unsafe.Pointer, count int) (*Set, error) { + _r0, _err := functions.QuadbinsetMake(values, count) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS quadbinset_end_value. +func (x *QuadbinSet) EndValue() (uint64, error) { + _r0, _err := functions.QuadbinsetEndValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// StartValue is MEOS quadbinset_start_value. +func (x *QuadbinSet) StartValue() (uint64, error) { + _r0, _err := functions.QuadbinsetStartValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ValueN is MEOS quadbinset_value_n. +func (x *QuadbinSet) ValueN(n int) (uint64, bool, error) { + _found, _value, _err := functions.QuadbinsetValueN(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 quadbinset_values. +func (x *QuadbinSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.QuadbinsetValues(functions.SetFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} diff --git a/types/raquet.go b/types/raquet.go index b5eab6d..d3041e1 100644 --- a/types/raquet.go +++ b/types/raquet.go @@ -68,8 +68,8 @@ func RaquetFromWKB(wkb unsafe.Pointer, size uint) (unsafe.Pointer, error) { return _r0, nil } -// RaquetFromHEXWKB is MEOS raquet_from_hexwkb. -func RaquetFromHEXWKB(hexwkb string) (unsafe.Pointer, error) { +// RaquetFromHexWKB is MEOS raquet_from_hexwkb. +func RaquetFromHexWKB(hexwkb string) (unsafe.Pointer, error) { _r0, _err := functions.RaquetFromHexwkb(hexwkb) if _err != nil { return nil, _err @@ -86,8 +86,8 @@ func RaquetAsWKB(rq unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (uns return _r0, nil } -// RaquetAsHEXWKB is MEOS raquet_as_hexwkb. -func RaquetAsHEXWKB(rq unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (string, error) { +// RaquetAsHexWKB is MEOS raquet_as_hexwkb. +func RaquetAsHexWKB(rq unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (string, error) { _r0, _err := functions.RaquetAsHexwkb(rq, variant, size_out) if _err != nil { return "", _err diff --git a/types/raster.go b/types/raster.go index d05299c..8c21e71 100644 --- a/types/raster.go +++ b/types/raster.go @@ -32,8 +32,8 @@ func RasterFromWKB(wkb unsafe.Pointer, size uint) (unsafe.Pointer, error) { return _r0, nil } -// RasterFromHEXWKB is MEOS raster_from_hexwkb. -func RasterFromHEXWKB(hexwkb string) (unsafe.Pointer, error) { +// RasterFromHexWKB is MEOS raster_from_hexwkb. +func RasterFromHexWKB(hexwkb string) (unsafe.Pointer, error) { _r0, _err := functions.RasterFromHexwkb(hexwkb) if _err != nil { return nil, _err @@ -50,8 +50,8 @@ func RasterAsWKB(rast unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (u return _r0, nil } -// RasterAsHEXWKB is MEOS raster_as_hexwkb. -func RasterAsHEXWKB(rast unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (string, error) { +// RasterAsHexWKB is MEOS raster_as_hexwkb. +func RasterAsHexWKB(rast unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (string, error) { _r0, _err := functions.RasterAsHexwkb(rast, variant, size_out) if _err != nil { return "", _err @@ -333,8 +333,8 @@ func RasterValueCount(rast unsafe.Pointer, band int, exclude_nodata bool, search } // RasterSetValues is MEOS raster_set_values. -func RasterSetValues(rast unsafe.Pointer, band int, x int, y int, width int, height int, values unsafe.Pointer, nodata unsafe.Pointer, noset unsafe.Pointer, count int, keepnodata bool) (unsafe.Pointer, error) { - _r0, _err := functions.RasterSetValues(rast, band, x, y, width, height, values, nodata, noset, count, keepnodata) +func RasterSetValues(rast unsafe.Pointer, band int, x int, y int, width int, height int, values unsafe.Pointer, nodata unsafe.Pointer, noset unsafe.Pointer, nosetwidth int, nosetheight int, count int, keepnodata bool) (unsafe.Pointer, error) { + _r0, _err := functions.RasterSetValues(rast, band, x, y, width, height, values, nodata, noset, nosetwidth, nosetheight, count, keepnodata) if _err != nil { return nil, _err } diff --git a/types/s2cellset.go b/types/s2cellset.go new file mode 100644 index 0000000..51da42d --- /dev/null +++ b/types/s2cellset.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 S2CellSet struct { + SpatialSet +} + +// S2CellSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func S2CellSetFromPointer(p unsafe.Pointer) *S2CellSet { + if p == nil { + return nil + } + v := &S2CellSet{} + v.ptr = p + return v +} + +// CompactCells is MEOS s2cellset_compact_cells. +func (x *S2CellSet) CompactCells() (*Set, error) { + _r0, _err := functions.S2cellsetCompactCells(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// UncompactCells is MEOS s2cellset_uncompact_cells. +func (x *S2CellSet) UncompactCells(resolution int) (*Set, error) { + _r0, _err := functions.S2cellsetUncompactCells(functions.SetFromPointer(x.Pointer()), resolution) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// CoverCells is MEOS s2cellset_cover_cells. +func (x *S2CellSet) CoverCells(resolution int) (*Set, error) { + _r0, _err := functions.S2cellsetCoverCells(functions.SetFromPointer(x.Pointer()), resolution) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// S2CellSetIn is MEOS s2cellset_in. +func S2CellSetIn(str string) (*Set, error) { + _r0, _err := functions.S2cellsetIn(str) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS s2cellset_out. +func (x *S2CellSet) Out() (string, error) { + _r0, _err := functions.S2cellsetOut(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// S2CellSetMake is MEOS s2cellset_make. +func S2CellSetMake(values unsafe.Pointer, count int) (*Set, error) { + _r0, _err := functions.S2cellsetMake(values, count) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS s2cellset_end_value. +func (x *S2CellSet) EndValue() (uint64, error) { + _r0, _err := functions.S2cellsetEndValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// StartValue is MEOS s2cellset_start_value. +func (x *S2CellSet) StartValue() (uint64, error) { + _r0, _err := functions.S2cellsetStartValue(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ValueN is MEOS s2cellset_value_n. +func (x *S2CellSet) ValueN(n int) (uint64, bool, error) { + _found, _value, _err := functions.S2cellsetValueN(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 s2cellset_values. +func (x *S2CellSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.S2cellsetValues(functions.SetFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} diff --git a/types/set.go b/types/set.go index a028d26..1500f3c 100644 --- a/types/set.go +++ b/types/set.go @@ -23,8 +23,8 @@ func SetFromPointer(p unsafe.Pointer) *Set { return v } -// AsHEXWKB is MEOS set_as_hexwkb. -func (x *Set) AsHEXWKB(variant uint8, size_out unsafe.Pointer) (string, error) { +// 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 @@ -41,8 +41,8 @@ func (x *Set) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, err return _r0, nil } -// SetFromHEXWKB is MEOS set_from_hexwkb. -func SetFromHEXWKB(hexwkb string) (*Set, error) { +// SetFromHexWKB is MEOS set_from_hexwkb. +func SetFromHexWKB(hexwkb string) (*Set, error) { _r0, _err := functions.SetFromHexwkb(hexwkb) if _err != nil { return nil, _err diff --git a/types/span.go b/types/span.go index 7c5ac38..4d1131c 100644 --- a/types/span.go +++ b/types/span.go @@ -23,8 +23,8 @@ func SpanFromPointer(p unsafe.Pointer) *Span { return v } -// AsHEXWKB is MEOS span_as_hexwkb. -func (x *Span) AsHEXWKB(variant uint8, size_out unsafe.Pointer) (string, error) { +// 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 @@ -41,8 +41,8 @@ func (x *Span) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, er return _r0, nil } -// SpanFromHEXWKB is MEOS span_from_hexwkb. -func SpanFromHEXWKB(hexwkb string) (*Span, error) { +// SpanFromHexWKB is MEOS span_from_hexwkb. +func SpanFromHexWKB(hexwkb string) (*Span, error) { _r0, _err := functions.SpanFromHexwkb(hexwkb) if _err != nil { return nil, _err diff --git a/types/spanset.go b/types/spanset.go index ae58bd6..4e9cbb0 100644 --- a/types/spanset.go +++ b/types/spanset.go @@ -23,8 +23,8 @@ func SpanSetFromPointer(p unsafe.Pointer) *SpanSet { return v } -// AsHEXWKB is MEOS spanset_as_hexwkb. -func (x *SpanSet) AsHEXWKB(variant uint8, size_out unsafe.Pointer) (string, error) { +// 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 @@ -41,8 +41,8 @@ func (x *SpanSet) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, return _r0, nil } -// SpanSetFromHEXWKB is MEOS spanset_from_hexwkb. -func SpanSetFromHEXWKB(hexwkb string) (*SpanSet, error) { +// SpanSetFromHexWKB is MEOS spanset_from_hexwkb. +func SpanSetFromHexWKB(hexwkb string) (*SpanSet, error) { _r0, _err := functions.SpansetFromHexwkb(hexwkb) if _err != nil { return nil, _err diff --git a/types/spatialset.go b/types/spatialset.go new file mode 100644 index 0000000..3af4c9f --- /dev/null +++ b/types/spatialset.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 SpatialSet struct { + Set +} + +// SpatialSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func SpatialSetFromPointer(p unsafe.Pointer) *SpatialSet { + if p == nil { + return nil + } + v := &SpatialSet{} + v.ptr = p + return v +} + +// Out is MEOS spatialset_out. +func (x *SpatialSet) Out(maxdd int) (string, error) { + _r0, _err := functions.SpatialsetOut(functions.SetFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// AsText is MEOS spatialset_as_text. +func (x *SpatialSet) AsText(maxdd int) (string, error) { + _r0, _err := functions.SpatialsetAsText(functions.SetFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// AsEWKB is MEOS spatialset_as_ewkb. +func (x *SpatialSet) AsEWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.SpatialsetAsEWKB(functions.SetFromPointer(x.Pointer()), variant, size_out) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// AsEWKT is MEOS spatialset_as_ewkt. +func (x *SpatialSet) AsEWKT(maxdd int) (string, error) { + _r0, _err := functions.SpatialsetAsEWKT(functions.SetFromPointer(x.Pointer()), maxdd) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// AsHexEWKB is MEOS spatialset_as_hexewkb. +func (x *SpatialSet) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { + _r0, _err := functions.SpatialsetAsHexewkb(functions.SetFromPointer(x.Pointer()), variant, size_out) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// SetSRID is MEOS spatialset_set_srid. +func (x *SpatialSet) SetSRID(srid int32) (*Set, error) { + _r0, _err := functions.SpatialsetSetSRID(functions.SetFromPointer(x.Pointer()), srid) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// SRID is MEOS spatialset_srid. +func (x *SpatialSet) SRID() (int32, error) { + _r0, _err := functions.SpatialsetSRID(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Transform is MEOS spatialset_transform. +func (x *SpatialSet) Transform(srid int32) (*Set, error) { + _r0, _err := functions.SpatialsetTransform(functions.SetFromPointer(x.Pointer()), srid) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// TransformPipeline is MEOS spatialset_transform_pipeline. +func (x *SpatialSet) TransformPipeline(pipelinestr string, srid int32, is_forward bool) (*Set, error) { + _r0, _err := functions.SpatialsetTransformPipeline(functions.SetFromPointer(x.Pointer()), pipelinestr, srid, is_forward) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// ToStbox is MEOS spatialset_to_stbox. +func (x *SpatialSet) ToStbox() (*STBox, error) { + _r0, _err := functions.SpatialsetToSTBOX(functions.SetFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} diff --git a/types/stbox.go b/types/stbox.go index 32e1a69..9c0d5ee 100644 --- a/types/stbox.go +++ b/types/stbox.go @@ -32,8 +32,8 @@ func (x *STBox) AsEWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, return _r0, nil } -// AsHEXEWKB is MEOS stbox_as_hexewkb. -func (x *STBox) AsHEXEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { +// AsHexEWKB is MEOS stbox_as_hexewkb. +func (x *STBox) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { _r0, _err := functions.STBOXAsHexewkb(functions.STBoxFromPointer(x.Pointer()), variant, size_out) if _err != nil { return "", _err @@ -41,8 +41,8 @@ func (x *STBox) AsHEXEWKB(variant uint8, size_out unsafe.Pointer) (string, error return _r0, nil } -// AsHEXWKB is MEOS stbox_as_hexwkb. -func (x *STBox) AsHEXWKB(variant uint8, size_out unsafe.Pointer) (string, error) { +// AsHexWKB is MEOS stbox_as_hexwkb. +func (x *STBox) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) { _r0, _err := functions.STBOXAsHexwkb(functions.STBoxFromPointer(x.Pointer()), variant, size_out) if _err != nil { return "", _err @@ -59,8 +59,8 @@ func (x *STBox) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, e return _r0, nil } -// STBoxFromHEXWKB is MEOS stbox_from_hexwkb. -func STBoxFromHEXWKB(hexwkb string) (*STBox, error) { +// STBoxFromHexWKB is MEOS stbox_from_hexwkb. +func STBoxFromHexWKB(hexwkb string) (*STBox, error) { _r0, _err := functions.STBOXFromHexwkb(hexwkb) if _err != nil { return nil, _err diff --git a/types/tbox.go b/types/tbox.go index c516aa3..841c673 100644 --- a/types/tbox.go +++ b/types/tbox.go @@ -23,8 +23,8 @@ func TBoxFromPointer(p unsafe.Pointer) *TBox { return v } -// AsHEXWKB is MEOS tbox_as_hexwkb. -func (x *TBox) AsHEXWKB(variant uint8, size_out unsafe.Pointer) (string, error) { +// 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 @@ -41,8 +41,8 @@ func (x *TBox) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, er return _r0, nil } -// TBoxFromHEXWKB is MEOS tbox_from_hexwkb. -func TBoxFromHEXWKB(hexwkb string) (*TBox, error) { +// TBoxFromHexWKB is MEOS tbox_from_hexwkb. +func TBoxFromHexWKB(hexwkb string) (*TBox, error) { _r0, _err := functions.TBOXFromHexwkb(hexwkb) if _err != nil { return nil, _err diff --git a/types/tcellindex.go b/types/tcellindex.go new file mode 100644 index 0000000..c637a58 --- /dev/null +++ b/types/tcellindex.go @@ -0,0 +1,80 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +// TCellIndex is temporal DGGS cell indexes, the types tcellindex_type of meos/src/temporal/tcellindex.c admits (T_TH3INDEX, T_TQUADBIN, T_TS2CELL): the tcellindex_* functions every cell family answers through its DggsCellOps. + +type TCellIndex struct { + TSpatial +} + +// TCellIndexFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TCellIndexFromPointer(p unsafe.Pointer) *TCellIndex { + if p == nil { + return nil + } + v := &TCellIndex{} + v.ptr = p + return v +} + +// GetResolution is MEOS tcellindex_get_resolution. +func (x *TCellIndex) GetResolution() (*Temporal, error) { + _r0, _err := functions.TcellindexGetResolution(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// IsValidCell is MEOS tcellindex_is_valid_cell. +func (x *TCellIndex) IsValidCell() (*Temporal, error) { + _r0, _err := functions.TcellindexIsValidCell(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// CellToParent is MEOS tcellindex_cell_to_parent. +func (x *TCellIndex) CellToParent(resolution int32) (*Temporal, error) { + _r0, _err := functions.TcellindexCellToParent(functions.TemporalFromPointer(x.Pointer()), resolution) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// CellToPoint is MEOS tcellindex_cell_to_point. +func (x *TCellIndex) CellToPoint() (*Temporal, error) { + _r0, _err := functions.TcellindexCellToPoint(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// CellToBoundary is MEOS tcellindex_cell_to_boundary. +func (x *TCellIndex) CellToBoundary() (*Temporal, error) { + _r0, _err := functions.TcellindexCellToBoundary(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// CellArea is MEOS tcellindex_cell_area. +func (x *TCellIndex) CellArea() (*Temporal, error) { + _r0, _err := functions.TcellindexCellArea(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/temporal.go b/types/temporal.go index aa17ff8..ee6edd4 100644 --- a/types/temporal.go +++ b/types/temporal.go @@ -25,8 +25,8 @@ func TemporalFromPointer(p unsafe.Pointer) *Temporal { return v } -// AsHEXWKB is MEOS temporal_as_hexwkb. -func (x *Temporal) AsHEXWKB(variant uint8, size_out unsafe.Pointer) (string, error) { +// 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 @@ -52,8 +52,8 @@ func (x *Temporal) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer return _r0, nil } -// TemporalFromHEXWKB is MEOS temporal_from_hexwkb. -func TemporalFromHEXWKB(hexwkb string) (*Temporal, error) { +// TemporalFromHexWKB is MEOS temporal_from_hexwkb. +func TemporalFromHexWKB(hexwkb string) (*Temporal, error) { _r0, _err := functions.TemporalFromHexwkb(hexwkb) if _err != nil { return nil, _err diff --git a/types/tgeo.go b/types/tgeo.go index 6d55732..e63e970 100644 --- a/types/tgeo.go +++ b/types/tgeo.go @@ -194,8 +194,17 @@ func (x *TGeo) Scale(xfactor float64, yfactor float64, zfactor float64) (*Tempor } // ScaleGeo is MEOS tgeo_scale_geo. -func (x *TGeo) ScaleGeo(scale *TRGeometrySeqSet, sorigin *TRGeometrySeqSet) (*Temporal, error) { - _r0, _err := functions.TgeoScaleGeo(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(scale.Pointer()), functions.GeomFromPointer(sorigin.Pointer())) +func (x *TGeo) ScaleGeo(scale *TRGeometrySeqSet) (*Temporal, error) { + _r0, _err := functions.TgeoScaleGeo(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(scale.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ScaleGeoOrigin is MEOS tgeo_scale_geo_origin. +func (x *TGeo) ScaleGeoOrigin(scale *TRGeometrySeqSet, sorigin *TRGeometrySeqSet) (*Temporal, error) { + _r0, _err := functions.TgeoScaleGeoOrigin(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(scale.Pointer()), functions.GeomFromPointer(sorigin.Pointer())) if _err != nil { return nil, _err } diff --git a/types/th3index.go b/types/th3index.go new file mode 100644 index 0000000..175651b --- /dev/null +++ b/types/th3index.go @@ -0,0 +1,372 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TH3Index struct { + TCellIndex +} + +// TH3IndexFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TH3IndexFromPointer(p unsafe.Pointer) *TH3Index { + if p == nil { + return nil + } + v := &TH3Index{} + v.ptr = p + return v +} + +// TH3IndexIn is MEOS th3index_in. +func TH3IndexIn(str string) (*Temporal, error) { + _r0, _err := functions.Th3indexIn(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS th3index_out. +func (x *TH3Index) Out() (string, error) { + _r0, _err := functions.Th3indexOut(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// TH3IndexFromMFJSON is MEOS th3index_from_mfjson. +func TH3IndexFromMFJSON(mfjson string) (*Temporal, error) { + _r0, _err := functions.Th3indexFromMFJSON(mfjson) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TH3IndexMake is MEOS th3index_make. +func TH3IndexMake(value uint64, t int64) (*Temporal, error) { + _r0, _err := functions.Th3indexMake(value, t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TH3IndexFromBaseTemp is MEOS th3index_from_base_temp. +func TH3IndexFromBaseTemp(value uint64, temp *Temporal) (*Temporal, error) { + _r0, _err := functions.Th3indexFromBaseTemp(value, functions.TemporalFromPointer(temp.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// StartValue is MEOS th3index_start_value. +func (x *TH3Index) StartValue() (uint64, error) { + _r0, _err := functions.Th3indexStartValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// EndValue is MEOS th3index_end_value. +func (x *TH3Index) EndValue() (uint64, error) { + _r0, _err := functions.Th3indexEndValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Value is MEOS th3index_value. +func (x *TH3Index) Value() (uint64, error) { + _r0, _err := functions.Th3indexValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ValueN is MEOS th3index_value_n. +func (x *TH3Index) ValueN(n int) (uint64, bool, error) { + _found, _value, _err := functions.Th3indexValueN(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 th3index_values. +func (x *TH3Index) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.Th3indexValues(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Unnest is MEOS th3index_unnest. +func (x *TH3Index) Unnest(values unsafe.Pointer, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.Th3indexUnnest(functions.TemporalFromPointer(x.Pointer()), values, count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// ValueAtTimestamptz is MEOS th3index_value_at_timestamptz. +func (x *TH3Index) ValueAtTimestamptz(t int64, strict bool) (uint64, bool, error) { + _found, _value, _err := functions.Th3indexValueAtTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, strict) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// ToTbigint is MEOS th3index_to_tbigint. +func (x *TH3Index) ToTbigint() (*Temporal, error) { + _r0, _err := functions.Th3indexToTbigint(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtValue is MEOS th3index_at_value. +func (x *TH3Index) AtValue(cell uint64) (*Temporal, error) { + _r0, _err := functions.Th3indexAtValue(functions.TemporalFromPointer(x.Pointer()), cell) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusValue is MEOS th3index_minus_value. +func (x *TH3Index) MinusValue(cell uint64) (*Temporal, error) { + _r0, _err := functions.Th3indexMinusValue(functions.TemporalFromPointer(x.Pointer()), cell) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// GetBaseCellNumber is MEOS th3index_get_base_cell_number. +func (x *TH3Index) GetBaseCellNumber() (*Temporal, error) { + _r0, _err := functions.Th3indexGetBaseCellNumber(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// IsResClassIii is MEOS th3index_is_res_class_iii. +func (x *TH3Index) IsResClassIii() (*Temporal, error) { + _r0, _err := functions.Th3indexIsResClassIii(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// IsPentagon is MEOS th3index_is_pentagon. +func (x *TH3Index) IsPentagon() (*Temporal, error) { + _r0, _err := functions.Th3indexIsPentagon(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// CellToParentNext is MEOS th3index_cell_to_parent_next. +func (x *TH3Index) CellToParentNext() (*Temporal, error) { + _r0, _err := functions.Th3indexCellToParentNext(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// CellToCenterChild is MEOS th3index_cell_to_center_child. +func (x *TH3Index) CellToCenterChild(resolution int32) (*Temporal, error) { + _r0, _err := functions.Th3indexCellToCenterChild(functions.TemporalFromPointer(x.Pointer()), resolution) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// CellToCenterChildNext is MEOS th3index_cell_to_center_child_next. +func (x *TH3Index) CellToCenterChildNext() (*Temporal, error) { + _r0, _err := functions.Th3indexCellToCenterChildNext(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// CellToChildPos is MEOS th3index_cell_to_child_pos. +func (x *TH3Index) CellToChildPos(parent_res int32) (*Temporal, error) { + _r0, _err := functions.Th3indexCellToChildPos(functions.TemporalFromPointer(x.Pointer()), parent_res) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ChildPosToCell is MEOS th3index_child_pos_to_cell. +func (x *TH3Index) ChildPosToCell(parent *Temporal, child_res int32) (*Temporal, error) { + _r0, _err := functions.Th3indexChildPosToCell(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(parent.Pointer()), child_res) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTgeogpoint is MEOS th3index_to_tgeogpoint. +func (x *TH3Index) ToTgeogpoint() (*Temporal, error) { + _r0, _err := functions.Th3indexToTgeogpoint(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTgeompoint is MEOS th3index_to_tgeompoint. +func (x *TH3Index) ToTgeompoint() (*Temporal, error) { + _r0, _err := functions.Th3indexToTgeompoint(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AreNeighborCells is MEOS th3index_are_neighbor_cells. +func (x *TH3Index) AreNeighborCells(dest *Temporal) (*Temporal, error) { + _r0, _err := functions.Th3indexAreNeighborCells(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(dest.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// CellsToDirectedEdge is MEOS th3index_cells_to_directed_edge. +func (x *TH3Index) CellsToDirectedEdge(dest *Temporal) (*Temporal, error) { + _r0, _err := functions.Th3indexCellsToDirectedEdge(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(dest.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// IsValidDirectedEdge is MEOS th3index_is_valid_directed_edge. +func (x *TH3Index) IsValidDirectedEdge() (*Temporal, error) { + _r0, _err := functions.Th3indexIsValidDirectedEdge(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// GetDirectedEdgeOrigin is MEOS th3index_get_directed_edge_origin. +func (x *TH3Index) GetDirectedEdgeOrigin() (*Temporal, error) { + _r0, _err := functions.Th3indexGetDirectedEdgeOrigin(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// GetDirectedEdgeDestination is MEOS th3index_get_directed_edge_destination. +func (x *TH3Index) GetDirectedEdgeDestination() (*Temporal, error) { + _r0, _err := functions.Th3indexGetDirectedEdgeDestination(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// DirectedEdgeToBoundary is MEOS th3index_directed_edge_to_boundary. +func (x *TH3Index) DirectedEdgeToBoundary() (*Temporal, error) { + _r0, _err := functions.Th3indexDirectedEdgeToBoundary(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// CellToVertex is MEOS th3index_cell_to_vertex. +func (x *TH3Index) CellToVertex(vertex_num int32) (*Temporal, error) { + _r0, _err := functions.Th3indexCellToVertex(functions.TemporalFromPointer(x.Pointer()), vertex_num) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// VertexToLatlng is MEOS th3index_vertex_to_latlng. +func (x *TH3Index) VertexToLatlng() (*Temporal, error) { + _r0, _err := functions.Th3indexVertexToLatlng(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// IsValidVertex is MEOS th3index_is_valid_vertex. +func (x *TH3Index) IsValidVertex() (*Temporal, error) { + _r0, _err := functions.Th3indexIsValidVertex(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// GridDistance is MEOS th3index_grid_distance. +func (x *TH3Index) GridDistance(dest *Temporal) (*Temporal, error) { + _r0, _err := functions.Th3indexGridDistance(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(dest.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// CellToLocalIj is MEOS th3index_cell_to_local_ij. +func (x *TH3Index) CellToLocalIj(cell *Temporal) (*Temporal, error) { + _r0, _err := functions.Th3indexCellToLocalIj(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(cell.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// LocalIjToCell is MEOS th3index_local_ij_to_cell. +func (x *TH3Index) LocalIjToCell(coord *Temporal) (*Temporal, error) { + _r0, _err := functions.Th3indexLocalIjToCell(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(coord.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// EdgeLength is MEOS th3index_edge_length. +func (x *TH3Index) EdgeLength() (*Temporal, error) { + _r0, _err := functions.Th3indexEdgeLength(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/th3indexinst.go b/types/th3indexinst.go new file mode 100644 index 0000000..5abaf92 --- /dev/null +++ b/types/th3indexinst.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 TH3IndexInst struct { + handle +} + +// TH3IndexInstFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TH3IndexInstFromPointer(p unsafe.Pointer) *TH3IndexInst { + if p == nil { + return nil + } + v := &TH3IndexInst{} + v.ptr = p + return v +} + +// TH3IndexInstMake is MEOS th3indexinst_make. +func TH3IndexInstMake(value uint64, t int64) (*Temporal, error) { + _r0, _err := functions.Th3indexinstMake(value, t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/th3indexseq.go b/types/th3indexseq.go new file mode 100644 index 0000000..42e28ca --- /dev/null +++ b/types/th3indexseq.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 TH3IndexSeq struct { + handle +} + +// TH3IndexSeqFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TH3IndexSeqFromPointer(p unsafe.Pointer) *TH3IndexSeq { + if p == nil { + return nil + } + v := &TH3IndexSeq{} + v.ptr = p + return v +} + +// TH3IndexSeqFromBaseTstzset is MEOS th3indexseq_from_base_tstzset. +func TH3IndexSeqFromBaseTstzset(value uint64, s *Set) (*Temporal, error) { + _r0, _err := functions.Th3indexseqFromBaseTstzset(value, functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TH3IndexSeqFromBaseTstzspan is MEOS th3indexseq_from_base_tstzspan. +func TH3IndexSeqFromBaseTstzspan(value uint64, s *Span) (*Temporal, error) { + _r0, _err := functions.Th3indexseqFromBaseTstzspan(value, functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TH3IndexSeqMake is MEOS th3indexseq_make. +func TH3IndexSeqMake(values unsafe.Pointer, times unsafe.Pointer, count int, lower_inc bool, upper_inc bool) (*Temporal, error) { + _r0, _err := functions.Th3indexseqMake(values, times, count, lower_inc, upper_inc) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/th3indexseqset.go b/types/th3indexseqset.go new file mode 100644 index 0000000..2a3e66e --- /dev/null +++ b/types/th3indexseqset.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 TH3IndexSeqSet struct { + handle +} + +// TH3IndexSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TH3IndexSeqSetFromPointer(p unsafe.Pointer) *TH3IndexSeqSet { + if p == nil { + return nil + } + v := &TH3IndexSeqSet{} + v.ptr = p + return v +} + +// TH3IndexSeqSetFromBaseTstzspanset is MEOS th3indexseqset_from_base_tstzspanset. +func TH3IndexSeqSetFromBaseTstzspanset(value uint64, ss *SpanSet) (*Temporal, error) { + _r0, _err := functions.Th3indexseqsetFromBaseTstzspanset(value, functions.SpanSetFromPointer(ss.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TH3IndexSeqSetMake is MEOS th3indexseqset_make. +func TH3IndexSeqSetMake(sequences unsafe.Pointer, count int) (*Temporal, error) { + _r0, _err := functions.Th3indexseqsetMake(sequences, count) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tpcbox.go b/types/tpcbox.go index b9fd910..8a35144 100644 --- a/types/tpcbox.go +++ b/types/tpcbox.go @@ -32,8 +32,8 @@ func (x *TPCBox) AsEWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, return _r0, nil } -// AsHEXEWKB is MEOS tpcbox_as_hexewkb. -func (x *TPCBox) AsHEXEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { +// AsHexEWKB is MEOS tpcbox_as_hexewkb. +func (x *TPCBox) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { _r0, _err := functions.TpcboxAsHexewkb(functions.TPCBoxFromPointer(x.Pointer()), variant, size_out) if _err != nil { return "", _err @@ -41,8 +41,8 @@ func (x *TPCBox) AsHEXEWKB(variant uint8, size_out unsafe.Pointer) (string, erro return _r0, nil } -// AsHEXWKB is MEOS tpcbox_as_hexwkb. -func (x *TPCBox) AsHEXWKB(variant uint8, size_out unsafe.Pointer) (string, error) { +// AsHexWKB is MEOS tpcbox_as_hexwkb. +func (x *TPCBox) AsHexWKB(variant uint8, size_out unsafe.Pointer) (string, error) { _r0, _err := functions.TpcboxAsHexwkb(functions.TPCBoxFromPointer(x.Pointer()), variant, size_out) if _err != nil { return "", _err @@ -59,8 +59,8 @@ func (x *TPCBox) AsWKB(variant uint8, size_out unsafe.Pointer) (unsafe.Pointer, return _r0, nil } -// TPCBoxFromHEXWKB is MEOS tpcbox_from_hexwkb. -func TPCBoxFromHEXWKB(hexwkb string) (*TPCBox, error) { +// TPCBoxFromHexWKB is MEOS tpcbox_from_hexwkb. +func TPCBoxFromHexWKB(hexwkb string) (*TPCBox, error) { _r0, _err := functions.TpcboxFromHexwkb(hexwkb) if _err != nil { return nil, _err diff --git a/types/tpcpatch.go b/types/tpcpatch.go new file mode 100644 index 0000000..e09a313 --- /dev/null +++ b/types/tpcpatch.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 TPcpatch struct { + TSpatial +} + +// TPcpatchFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TPcpatchFromPointer(p unsafe.Pointer) *TPcpatch { + if p == nil { + return nil + } + v := &TPcpatch{} + v.ptr = p + return v +} + +// TPcpatchIn is MEOS tpcpatch_in. +func TPcpatchIn(str string) (*Temporal, error) { + _r0, _err := functions.TpcpatchIn(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS tpcpatch_out. +func (x *TPcpatch) Out() (string, error) { + _r0, _err := functions.TpcpatchOut(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// TPcpatchFromMFJSON is MEOS tpcpatch_from_mfjson. +func TPcpatchFromMFJSON(mfjson string) (*Temporal, error) { + _r0, _err := functions.TpcpatchFromMFJSON(mfjson) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTgeometry is MEOS tpcpatch_to_tgeometry. +func (x *TPcpatch) ToTgeometry() (*Temporal, error) { + _r0, _err := functions.TpcpatchToTgeometry(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TPcpatchFromBaseTemp is MEOS tpcpatch_from_base_temp. +func TPcpatchFromBaseTemp(pa *Pcpatch, temp *Temporal) (*Temporal, error) { + _r0, _err := functions.TpcpatchFromBaseTemp(functions.PcpatchFromPointer(pa.Pointer()), functions.TemporalFromPointer(temp.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// StartValue is MEOS tpcpatch_start_value. +func (x *TPcpatch) StartValue() (*Pcpatch, error) { + _r0, _err := functions.TpcpatchStartValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return PcpatchFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS tpcpatch_end_value. +func (x *TPcpatch) EndValue() (*Pcpatch, error) { + _r0, _err := functions.TpcpatchEndValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return PcpatchFromPointer(_r0.Pointer()), nil +} + +// Value is MEOS tpcpatch_value. +func (x *TPcpatch) Value() (*Pcpatch, error) { + _r0, _err := functions.TpcpatchValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return PcpatchFromPointer(_r0.Pointer()), nil +} + +// ValueN is MEOS tpcpatch_value_n. +func (x *TPcpatch) ValueN(n int) (*Pcpatch, bool, error) { + _found, _value, _err := functions.TpcpatchValueN(functions.TemporalFromPointer(x.Pointer()), n) + if _err != nil { + return nil, false, _err + } + if !_found { + return nil, false, nil + } + return PcpatchFromPointer(_value.Pointer()), true, nil +} + +// Values is MEOS tpcpatch_values. +func (x *TPcpatch) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TpcpatchValues(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Unnest is MEOS tpcpatch_unnest. +func (x *TPcpatch) Unnest(values unsafe.Pointer, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TpcpatchUnnest(functions.TemporalFromPointer(x.Pointer()), values, count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// ValueAtTimestamptz is MEOS tpcpatch_value_at_timestamptz. +func (x *TPcpatch) ValueAtTimestamptz(t int64, strict bool) (*Pcpatch, bool, error) { + _found, _value, _err := functions.TpcpatchValueAtTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, strict) + if _err != nil { + return nil, false, _err + } + if !_found { + return nil, false, nil + } + return PcpatchFromPointer(_value.Pointer()), true, nil +} + +// AtValue is MEOS tpcpatch_at_value. +func (x *TPcpatch) AtValue(pa *Pcpatch) (*Temporal, error) { + _r0, _err := functions.TpcpatchAtValue(functions.TemporalFromPointer(x.Pointer()), functions.PcpatchFromPointer(pa.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusValue is MEOS tpcpatch_minus_value. +func (x *TPcpatch) MinusValue(pa *Pcpatch) (*Temporal, error) { + _r0, _err := functions.TpcpatchMinusValue(functions.TemporalFromPointer(x.Pointer()), functions.PcpatchFromPointer(pa.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Pcid is MEOS tpcpatch_pcid. +func (x *TPcpatch) Pcid() (uint32, error) { + _r0, _err := functions.TpcpatchPcid(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// StartNpoints is MEOS tpcpatch_start_npoints. +func (x *TPcpatch) StartNpoints() (uint32, error) { + _r0, _err := functions.TpcpatchStartNpoints(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// EndNpoints is MEOS tpcpatch_end_npoints. +func (x *TPcpatch) EndNpoints() (uint32, error) { + _r0, _err := functions.TpcpatchEndNpoints(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Npoints is MEOS tpcpatch_npoints. +func (x *TPcpatch) Npoints() (int64, error) { + _r0, _err := functions.TpcpatchNpoints(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} diff --git a/types/tpcpatchinst.go b/types/tpcpatchinst.go new file mode 100644 index 0000000..4377945 --- /dev/null +++ b/types/tpcpatchinst.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 TPcpatchInst struct { + handle +} + +// TPcpatchInstFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TPcpatchInstFromPointer(p unsafe.Pointer) *TPcpatchInst { + if p == nil { + return nil + } + v := &TPcpatchInst{} + v.ptr = p + return v +} + +// TPcpatchInstMake is MEOS tpcpatchinst_make. +func TPcpatchInstMake(pa *Pcpatch, t int64) (*Temporal, error) { + _r0, _err := functions.TpcpatchinstMake(functions.PcpatchFromPointer(pa.Pointer()), t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tpcpatchseq.go b/types/tpcpatchseq.go new file mode 100644 index 0000000..8ca1362 --- /dev/null +++ b/types/tpcpatchseq.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 TPcpatchSeq struct { + handle +} + +// TPcpatchSeqFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TPcpatchSeqFromPointer(p unsafe.Pointer) *TPcpatchSeq { + if p == nil { + return nil + } + v := &TPcpatchSeq{} + v.ptr = p + return v +} + +// TPcpatchSeqFromBaseTstzset is MEOS tpcpatchseq_from_base_tstzset. +func TPcpatchSeqFromBaseTstzset(pa *Pcpatch, s *Set) (*Temporal, error) { + _r0, _err := functions.TpcpatchseqFromBaseTstzset(functions.PcpatchFromPointer(pa.Pointer()), functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TPcpatchSeqFromBaseTstzspan is MEOS tpcpatchseq_from_base_tstzspan. +func TPcpatchSeqFromBaseTstzspan(pa *Pcpatch, sp *Span) (*Temporal, error) { + _r0, _err := functions.TpcpatchseqFromBaseTstzspan(functions.PcpatchFromPointer(pa.Pointer()), functions.SpanFromPointer(sp.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tpcpatchseqset.go b/types/tpcpatchseqset.go new file mode 100644 index 0000000..0d36e10 --- /dev/null +++ b/types/tpcpatchseqset.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 TPcpatchSeqSet struct { + handle +} + +// TPcpatchSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TPcpatchSeqSetFromPointer(p unsafe.Pointer) *TPcpatchSeqSet { + if p == nil { + return nil + } + v := &TPcpatchSeqSet{} + v.ptr = p + return v +} + +// TPcpatchSeqSetFromBaseTstzspanset is MEOS tpcpatchseqset_from_base_tstzspanset. +func TPcpatchSeqSetFromBaseTstzspanset(pa *Pcpatch, ss *SpanSet) (*Temporal, error) { + _r0, _err := functions.TpcpatchseqsetFromBaseTstzspanset(functions.PcpatchFromPointer(pa.Pointer()), functions.SpanSetFromPointer(ss.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tpcpoint.go b/types/tpcpoint.go new file mode 100644 index 0000000..7ebaac6 --- /dev/null +++ b/types/tpcpoint.go @@ -0,0 +1,165 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TPcpoint struct { + TSpatial +} + +// TPcpointFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TPcpointFromPointer(p unsafe.Pointer) *TPcpoint { + if p == nil { + return nil + } + v := &TPcpoint{} + v.ptr = p + return v +} + +// TPcpointIn is MEOS tpcpoint_in. +func TPcpointIn(str string) (*Temporal, error) { + _r0, _err := functions.TpcpointIn(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS tpcpoint_out. +func (x *TPcpoint) Out() (string, error) { + _r0, _err := functions.TpcpointOut(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// TPcpointFromMFJSON is MEOS tpcpoint_from_mfjson. +func TPcpointFromMFJSON(mfjson string) (*Temporal, error) { + _r0, _err := functions.TpcpointFromMFJSON(mfjson) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTgeompoint is MEOS tpcpoint_to_tgeompoint. +func (x *TPcpoint) ToTgeompoint() (*Temporal, error) { + _r0, _err := functions.TpcpointToTgeompoint(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TPcpointFromBaseTemp is MEOS tpcpoint_from_base_temp. +func TPcpointFromBaseTemp(pt *Pcpoint, temp *Temporal) (*Temporal, error) { + _r0, _err := functions.TpcpointFromBaseTemp(functions.PcpointFromPointer(pt.Pointer()), functions.TemporalFromPointer(temp.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// StartValue is MEOS tpcpoint_start_value. +func (x *TPcpoint) StartValue() (*Pcpoint, error) { + _r0, _err := functions.TpcpointStartValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return PcpointFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS tpcpoint_end_value. +func (x *TPcpoint) EndValue() (*Pcpoint, error) { + _r0, _err := functions.TpcpointEndValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return PcpointFromPointer(_r0.Pointer()), nil +} + +// Value is MEOS tpcpoint_value. +func (x *TPcpoint) Value() (*Pcpoint, error) { + _r0, _err := functions.TpcpointValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return PcpointFromPointer(_r0.Pointer()), nil +} + +// ValueN is MEOS tpcpoint_value_n. +func (x *TPcpoint) ValueN(n int) (*Pcpoint, bool, error) { + _found, _value, _err := functions.TpcpointValueN(functions.TemporalFromPointer(x.Pointer()), n) + if _err != nil { + return nil, false, _err + } + if !_found { + return nil, false, nil + } + return PcpointFromPointer(_value.Pointer()), true, nil +} + +// Values is MEOS tpcpoint_values. +func (x *TPcpoint) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TpcpointValues(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Unnest is MEOS tpcpoint_unnest. +func (x *TPcpoint) Unnest(values unsafe.Pointer, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TpcpointUnnest(functions.TemporalFromPointer(x.Pointer()), values, count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// ValueAtTimestamptz is MEOS tpcpoint_value_at_timestamptz. +func (x *TPcpoint) ValueAtTimestamptz(t int64, strict bool) (*Pcpoint, bool, error) { + _found, _value, _err := functions.TpcpointValueAtTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, strict) + if _err != nil { + return nil, false, _err + } + if !_found { + return nil, false, nil + } + return PcpointFromPointer(_value.Pointer()), true, nil +} + +// AtValue is MEOS tpcpoint_at_value. +func (x *TPcpoint) AtValue(pt *Pcpoint) (*Temporal, error) { + _r0, _err := functions.TpcpointAtValue(functions.TemporalFromPointer(x.Pointer()), functions.PcpointFromPointer(pt.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusValue is MEOS tpcpoint_minus_value. +func (x *TPcpoint) MinusValue(pt *Pcpoint) (*Temporal, error) { + _r0, _err := functions.TpcpointMinusValue(functions.TemporalFromPointer(x.Pointer()), functions.PcpointFromPointer(pt.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Pcid is MEOS tpcpoint_pcid. +func (x *TPcpoint) Pcid() (uint32, error) { + _r0, _err := functions.TpcpointPcid(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} diff --git a/types/tpcpointinst.go b/types/tpcpointinst.go new file mode 100644 index 0000000..3b071e2 --- /dev/null +++ b/types/tpcpointinst.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 TPcpointInst struct { + handle +} + +// TPcpointInstFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TPcpointInstFromPointer(p unsafe.Pointer) *TPcpointInst { + if p == nil { + return nil + } + v := &TPcpointInst{} + v.ptr = p + return v +} + +// TPcpointInstMake is MEOS tpcpointinst_make. +func TPcpointInstMake(pt *Pcpoint, t int64) (*Temporal, error) { + _r0, _err := functions.TpcpointinstMake(functions.PcpointFromPointer(pt.Pointer()), t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tpcpointseq.go b/types/tpcpointseq.go new file mode 100644 index 0000000..37899c5 --- /dev/null +++ b/types/tpcpointseq.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 TPcpointSeq struct { + handle +} + +// TPcpointSeqFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TPcpointSeqFromPointer(p unsafe.Pointer) *TPcpointSeq { + if p == nil { + return nil + } + v := &TPcpointSeq{} + v.ptr = p + return v +} + +// TPcpointSeqFromBaseTstzset is MEOS tpcpointseq_from_base_tstzset. +func TPcpointSeqFromBaseTstzset(pt *Pcpoint, s *Set) (*Temporal, error) { + _r0, _err := functions.TpcpointseqFromBaseTstzset(functions.PcpointFromPointer(pt.Pointer()), functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TPcpointSeqFromBaseTstzspan is MEOS tpcpointseq_from_base_tstzspan. +func TPcpointSeqFromBaseTstzspan(pt *Pcpoint, sp *Span) (*Temporal, error) { + _r0, _err := functions.TpcpointseqFromBaseTstzspan(functions.PcpointFromPointer(pt.Pointer()), functions.SpanFromPointer(sp.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tpcpointseqset.go b/types/tpcpointseqset.go new file mode 100644 index 0000000..5b67516 --- /dev/null +++ b/types/tpcpointseqset.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 TPcpointSeqSet struct { + handle +} + +// TPcpointSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TPcpointSeqSetFromPointer(p unsafe.Pointer) *TPcpointSeqSet { + if p == nil { + return nil + } + v := &TPcpointSeqSet{} + v.ptr = p + return v +} + +// TPcpointSeqSetFromBaseTstzspanset is MEOS tpcpointseqset_from_base_tstzspanset. +func TPcpointSeqSetFromBaseTstzspanset(pt *Pcpoint, ss *SpanSet) (*Temporal, error) { + _r0, _err := functions.TpcpointseqsetFromBaseTstzspanset(functions.PcpointFromPointer(pt.Pointer()), functions.SpanSetFromPointer(ss.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tposechain.go b/types/tposechain.go new file mode 100644 index 0000000..6247eb5 --- /dev/null +++ b/types/tposechain.go @@ -0,0 +1,195 @@ +package types + +// Code generated by tools/objectgen.py from meos-idl.json. DO NOT EDIT. + +import ( + "unsafe" + + "github.com/MobilityDB/GoMEOS/functions" +) + +type TPoseChain struct { + TSpatial +} + +// TPoseChainFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TPoseChainFromPointer(p unsafe.Pointer) *TPoseChain { + if p == nil { + return nil + } + v := &TPoseChain{} + v.ptr = p + return v +} + +// TPoseChainFromGeopose is MEOS tposechain_from_geopose. +func TPoseChainFromGeopose(json string) (*Temporal, error) { + _r0, _err := functions.TposechainFromGeopose(json) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AsGeopose is MEOS tposechain_as_geopose. +func (x *TPoseChain) AsGeopose(precision int) (string, error) { + _r0, _err := functions.TposechainAsGeopose(functions.TemporalFromPointer(x.Pointer()), precision) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// TPoseChainIn is MEOS tposechain_in. +func TPoseChainIn(str string) (*Temporal, error) { + _r0, _err := functions.TposechainIn(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TPoseChainFromMFJSON is MEOS tposechain_from_mfjson. +func TPoseChainFromMFJSON(mfjson string) (*Temporal, error) { + _r0, _err := functions.TposechainFromMFJSON(mfjson) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TPoseChainFromBaseTemp is MEOS tposechain_from_base_temp. +func TPoseChainFromBaseTemp(pc unsafe.Pointer, temp *Temporal) (*Temporal, error) { + _r0, _err := functions.TposechainFromBaseTemp(pc, functions.TemporalFromPointer(temp.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ToTpose is MEOS tposechain_to_tpose. +func (x *TPoseChain) ToTpose() (*Temporal, error) { + _r0, _err := functions.TposechainToTpose(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// EndValue is MEOS tposechain_end_value. +func (x *TPoseChain) EndValue() (unsafe.Pointer, error) { + _r0, _err := functions.TposechainEndValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// NumPoses is MEOS tposechain_num_poses. +func (x *TPoseChain) NumPoses() (int, error) { + _r0, _err := functions.TposechainNumPoses(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// StartValue is MEOS tposechain_start_value. +func (x *TPoseChain) StartValue() (unsafe.Pointer, error) { + _r0, _err := functions.TposechainStartValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Value is MEOS tposechain_value. +func (x *TPoseChain) Value() (unsafe.Pointer, error) { + _r0, _err := functions.TposechainValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Values is MEOS tposechain_values. +func (x *TPoseChain) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TposechainValues(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Unnest is MEOS tposechain_unnest. +func (x *TPoseChain) Unnest(values unsafe.Pointer, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TposechainUnnest(functions.TemporalFromPointer(x.Pointer()), values, count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Rotate is MEOS tposechain_rotate. +func (x *TPoseChain) Rotate(angle float64, x0 float64, y0 float64) (*Temporal, error) { + _r0, _err := functions.TposechainRotate(functions.TemporalFromPointer(x.Pointer()), angle, x0, y0) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// RotateX is MEOS tposechain_rotate_x. +func (x *TPoseChain) RotateX(angle float64) (*Temporal, error) { + _r0, _err := functions.TposechainRotateX(functions.TemporalFromPointer(x.Pointer()), angle) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// RotateY is MEOS tposechain_rotate_y. +func (x *TPoseChain) RotateY(angle float64) (*Temporal, error) { + _r0, _err := functions.TposechainRotateY(functions.TemporalFromPointer(x.Pointer()), angle) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// RotateZ is MEOS tposechain_rotate_z. +func (x *TPoseChain) RotateZ(angle float64) (*Temporal, error) { + _r0, _err := functions.TposechainRotateZ(functions.TemporalFromPointer(x.Pointer()), angle) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Translate is MEOS tposechain_translate. +func (x *TPoseChain) Translate(deltax float64, deltay float64, deltaz float64) (*Temporal, error) { + _r0, _err := functions.TposechainTranslate(functions.TemporalFromPointer(x.Pointer()), deltax, deltay, deltaz) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtValue is MEOS tposechain_at_value. +func (x *TPoseChain) AtValue(pc unsafe.Pointer) (*Temporal, error) { + _r0, _err := functions.TposechainAtValue(functions.TemporalFromPointer(x.Pointer()), pc) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusValue is MEOS tposechain_minus_value. +func (x *TPoseChain) MinusValue(pc unsafe.Pointer) (*Temporal, error) { + _r0, _err := functions.TposechainMinusValue(functions.TemporalFromPointer(x.Pointer()), pc) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tposechaininst.go b/types/tposechaininst.go new file mode 100644 index 0000000..d38a0b3 --- /dev/null +++ b/types/tposechaininst.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 TPoseChainInst struct { + handle +} + +// TPoseChainInstFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TPoseChainInstFromPointer(p unsafe.Pointer) *TPoseChainInst { + if p == nil { + return nil + } + v := &TPoseChainInst{} + v.ptr = p + return v +} + +// TPoseChainInstMake is MEOS tposechaininst_make. +func TPoseChainInstMake(pc unsafe.Pointer, t int64) (*Temporal, error) { + _r0, _err := functions.TposechaininstMake(pc, t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tposechainseq.go b/types/tposechainseq.go new file mode 100644 index 0000000..c739515 --- /dev/null +++ b/types/tposechainseq.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 TPoseChainSeq struct { + handle +} + +// TPoseChainSeqFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TPoseChainSeqFromPointer(p unsafe.Pointer) *TPoseChainSeq { + if p == nil { + return nil + } + v := &TPoseChainSeq{} + v.ptr = p + return v +} + +// TPoseChainSeqFromBaseTstzset is MEOS tposechainseq_from_base_tstzset. +func TPoseChainSeqFromBaseTstzset(pc unsafe.Pointer, s *Set) (*Temporal, error) { + _r0, _err := functions.TposechainseqFromBaseTstzset(pc, functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TPoseChainSeqFromBaseTstzspan is MEOS tposechainseq_from_base_tstzspan. +func TPoseChainSeqFromBaseTstzspan(pc unsafe.Pointer, s *Span, interp functions.Interpolation) (*Temporal, error) { + _r0, _err := functions.TposechainseqFromBaseTstzspan(pc, functions.SpanFromPointer(s.Pointer()), interp) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tposechainseqset.go b/types/tposechainseqset.go new file mode 100644 index 0000000..1416c44 --- /dev/null +++ b/types/tposechainseqset.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 TPoseChainSeqSet struct { + handle +} + +// TPoseChainSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TPoseChainSeqSetFromPointer(p unsafe.Pointer) *TPoseChainSeqSet { + if p == nil { + return nil + } + v := &TPoseChainSeqSet{} + v.ptr = p + return v +} + +// TPoseChainSeqSetFromBaseTstzspanset is MEOS tposechainseqset_from_base_tstzspanset. +func TPoseChainSeqSetFromBaseTstzspanset(pc unsafe.Pointer, ss *SpanSet, interp functions.Interpolation) (*Temporal, error) { + _r0, _err := functions.TposechainseqsetFromBaseTstzspanset(pc, functions.SpanSetFromPointer(ss.Pointer()), interp) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tquadbin.go b/types/tquadbin.go new file mode 100644 index 0000000..b62d79f --- /dev/null +++ b/types/tquadbin.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 TQuadbin struct { + TCellIndex +} + +// TQuadbinFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TQuadbinFromPointer(p unsafe.Pointer) *TQuadbin { + if p == nil { + return nil + } + v := &TQuadbin{} + v.ptr = p + return v +} + +// TQuadbinIn is MEOS tquadbin_in. +func TQuadbinIn(str string) (*Temporal, error) { + _r0, _err := functions.TquadbinIn(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS tquadbin_out. +func (x *TQuadbin) Out() (string, error) { + _r0, _err := functions.TquadbinOut(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// TQuadbinFromMFJSON is MEOS tquadbin_from_mfjson. +func TQuadbinFromMFJSON(mfjson string) (*Temporal, error) { + _r0, _err := functions.TquadbinFromMFJSON(mfjson) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TQuadbinMake is MEOS tquadbin_make. +func TQuadbinMake(value uint64, t int64) (*Temporal, error) { + _r0, _err := functions.TquadbinMake(value, t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TQuadbinFromBaseTemp is MEOS tquadbin_from_base_temp. +func TQuadbinFromBaseTemp(value uint64, temp *Temporal) (*Temporal, error) { + _r0, _err := functions.TquadbinFromBaseTemp(value, functions.TemporalFromPointer(temp.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// StartValue is MEOS tquadbin_start_value. +func (x *TQuadbin) StartValue() (uint64, error) { + _r0, _err := functions.TquadbinStartValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// EndValue is MEOS tquadbin_end_value. +func (x *TQuadbin) EndValue() (uint64, error) { + _r0, _err := functions.TquadbinEndValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Value is MEOS tquadbin_value. +func (x *TQuadbin) Value() (uint64, error) { + _r0, _err := functions.TquadbinValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ValueN is MEOS tquadbin_value_n. +func (x *TQuadbin) ValueN(n int) (uint64, bool, error) { + _found, _value, _err := functions.TquadbinValueN(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 tquadbin_values. +func (x *TQuadbin) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TquadbinValues(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Unnest is MEOS tquadbin_unnest. +func (x *TQuadbin) Unnest(values unsafe.Pointer, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TquadbinUnnest(functions.TemporalFromPointer(x.Pointer()), values, count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// ValueAtTimestamptz is MEOS tquadbin_value_at_timestamptz. +func (x *TQuadbin) ValueAtTimestamptz(t int64, strict bool) (uint64, bool, error) { + _found, _value, _err := functions.TquadbinValueAtTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, strict) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// ToTbigint is MEOS tquadbin_to_tbigint. +func (x *TQuadbin) ToTbigint() (*Temporal, error) { + _r0, _err := functions.TquadbinToTbigint(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtValue is MEOS tquadbin_at_value. +func (x *TQuadbin) AtValue(cell uint64) (*Temporal, error) { + _r0, _err := functions.TquadbinAtValue(functions.TemporalFromPointer(x.Pointer()), cell) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusValue is MEOS tquadbin_minus_value. +func (x *TQuadbin) MinusValue(cell uint64) (*Temporal, error) { + _r0, _err := functions.TquadbinMinusValue(functions.TemporalFromPointer(x.Pointer()), cell) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// CellToQuadkey is MEOS tquadbin_cell_to_quadkey. +func (x *TQuadbin) CellToQuadkey() (*Temporal, error) { + _r0, _err := functions.TquadbinCellToQuadkey(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// GridDistance is MEOS tquadbin_grid_distance. +func (x *TQuadbin) GridDistance(dest *Temporal) (*Temporal, error) { + _r0, _err := functions.TquadbinGridDistance(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(dest.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tquadbininst.go b/types/tquadbininst.go new file mode 100644 index 0000000..c59c21d --- /dev/null +++ b/types/tquadbininst.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 TQuadbinInst struct { + handle +} + +// TQuadbinInstFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TQuadbinInstFromPointer(p unsafe.Pointer) *TQuadbinInst { + if p == nil { + return nil + } + v := &TQuadbinInst{} + v.ptr = p + return v +} + +// TQuadbinInstMake is MEOS tquadbininst_make. +func TQuadbinInstMake(value uint64, t int64) (*Temporal, error) { + _r0, _err := functions.TquadbininstMake(value, t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tquadbinseq.go b/types/tquadbinseq.go new file mode 100644 index 0000000..a5190e3 --- /dev/null +++ b/types/tquadbinseq.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 TQuadbinSeq struct { + handle +} + +// TQuadbinSeqFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TQuadbinSeqFromPointer(p unsafe.Pointer) *TQuadbinSeq { + if p == nil { + return nil + } + v := &TQuadbinSeq{} + v.ptr = p + return v +} + +// TQuadbinSeqFromBaseTstzset is MEOS tquadbinseq_from_base_tstzset. +func TQuadbinSeqFromBaseTstzset(value uint64, s *Set) (*Temporal, error) { + _r0, _err := functions.TquadbinseqFromBaseTstzset(value, functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TQuadbinSeqFromBaseTstzspan is MEOS tquadbinseq_from_base_tstzspan. +func TQuadbinSeqFromBaseTstzspan(value uint64, s *Span) (*Temporal, error) { + _r0, _err := functions.TquadbinseqFromBaseTstzspan(value, functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TQuadbinSeqMake is MEOS tquadbinseq_make. +func TQuadbinSeqMake(values unsafe.Pointer, times unsafe.Pointer, count int, lower_inc bool, upper_inc bool) (*Temporal, error) { + _r0, _err := functions.TquadbinseqMake(values, times, count, lower_inc, upper_inc) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tquadbinseqset.go b/types/tquadbinseqset.go new file mode 100644 index 0000000..6bf4130 --- /dev/null +++ b/types/tquadbinseqset.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 TQuadbinSeqSet struct { + handle +} + +// TQuadbinSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TQuadbinSeqSetFromPointer(p unsafe.Pointer) *TQuadbinSeqSet { + if p == nil { + return nil + } + v := &TQuadbinSeqSet{} + v.ptr = p + return v +} + +// TQuadbinSeqSetFromBaseTstzspanset is MEOS tquadbinseqset_from_base_tstzspanset. +func TQuadbinSeqSetFromBaseTstzspanset(value uint64, ss *SpanSet) (*Temporal, error) { + _r0, _err := functions.TquadbinseqsetFromBaseTstzspanset(value, functions.SpanSetFromPointer(ss.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TQuadbinSeqSetMake is MEOS tquadbinseqset_make. +func TQuadbinSeqSetMake(sequences unsafe.Pointer, count int) (*Temporal, error) { + _r0, _err := functions.TquadbinseqsetMake(sequences, count) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/trgeometry.go b/types/trgeometry.go index ae0c9c7..b1d9a56 100644 --- a/types/trgeometry.go +++ b/types/trgeometry.go @@ -278,6 +278,18 @@ func (x *TRGeometry) ValueN(n int) (*TRGeometrySeqSet, bool, error) { return TRGeometrySeqSetFromPointer(_value.Pointer()), true, nil } +// ValueAtTimestamptz is MEOS trgeometry_value_at_timestamptz. +func (x *TRGeometry) ValueAtTimestamptz(t int64, strict bool) (*TRGeometrySeqSet, bool, error) { + _found, _value, _err := functions.TrgeometryValueAtTimestamptz(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 +} + // 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) diff --git a/types/ts2cell.go b/types/ts2cell.go new file mode 100644 index 0000000..89eceeb --- /dev/null +++ b/types/ts2cell.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 TS2Cell struct { + TCellIndex +} + +// TS2CellFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TS2CellFromPointer(p unsafe.Pointer) *TS2Cell { + if p == nil { + return nil + } + v := &TS2Cell{} + v.ptr = p + return v +} + +// TS2CellIn is MEOS ts2cell_in. +func TS2CellIn(str string) (*Temporal, error) { + _r0, _err := functions.Ts2cellIn(str) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Out is MEOS ts2cell_out. +func (x *TS2Cell) Out() (string, error) { + _r0, _err := functions.Ts2cellOut(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return "", _err + } + return _r0, nil +} + +// TS2CellFromMFJSON is MEOS ts2cell_from_mfjson. +func TS2CellFromMFJSON(mfjson string) (*Temporal, error) { + _r0, _err := functions.Ts2cellFromMFJSON(mfjson) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TS2CellMake is MEOS ts2cell_make. +func TS2CellMake(value uint64, t int64) (*Temporal, error) { + _r0, _err := functions.Ts2cellMake(value, t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TS2CellFromBaseTemp is MEOS ts2cell_from_base_temp. +func TS2CellFromBaseTemp(value uint64, temp *Temporal) (*Temporal, error) { + _r0, _err := functions.Ts2cellFromBaseTemp(value, functions.TemporalFromPointer(temp.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// StartValue is MEOS ts2cell_start_value. +func (x *TS2Cell) StartValue() (uint64, error) { + _r0, _err := functions.Ts2cellStartValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// EndValue is MEOS ts2cell_end_value. +func (x *TS2Cell) EndValue() (uint64, error) { + _r0, _err := functions.Ts2cellEndValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// Value is MEOS ts2cell_value. +func (x *TS2Cell) Value() (uint64, error) { + _r0, _err := functions.Ts2cellValue(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return 0, _err + } + return _r0, nil +} + +// ValueN is MEOS ts2cell_value_n. +func (x *TS2Cell) ValueN(n int) (uint64, bool, error) { + _found, _value, _err := functions.Ts2cellValueN(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 ts2cell_values. +func (x *TS2Cell) Values(count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.Ts2cellValues(functions.TemporalFromPointer(x.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// Unnest is MEOS ts2cell_unnest. +func (x *TS2Cell) Unnest(values unsafe.Pointer, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.Ts2cellUnnest(functions.TemporalFromPointer(x.Pointer()), values, count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// ValueAtTimestamptz is MEOS ts2cell_value_at_timestamptz. +func (x *TS2Cell) ValueAtTimestamptz(t int64, strict bool) (uint64, bool, error) { + _found, _value, _err := functions.Ts2cellValueAtTimestamptz(functions.TemporalFromPointer(x.Pointer()), t, strict) + if _err != nil { + return 0, false, _err + } + if !_found { + return 0, false, nil + } + return _value, true, nil +} + +// ToTbigint is MEOS ts2cell_to_tbigint. +func (x *TS2Cell) ToTbigint() (*Temporal, error) { + _r0, _err := functions.Ts2cellToTbigint(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// AtValue is MEOS ts2cell_at_value. +func (x *TS2Cell) AtValue(cell uint64) (*Temporal, error) { + _r0, _err := functions.Ts2cellAtValue(functions.TemporalFromPointer(x.Pointer()), cell) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// MinusValue is MEOS ts2cell_minus_value. +func (x *TS2Cell) MinusValue(cell uint64) (*Temporal, error) { + _r0, _err := functions.Ts2cellMinusValue(functions.TemporalFromPointer(x.Pointer()), cell) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// CellToToken is MEOS ts2cell_cell_to_token. +func (x *TS2Cell) CellToToken() (*Temporal, error) { + _r0, _err := functions.Ts2cellCellToToken(functions.TemporalFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// GridDistance is MEOS ts2cell_grid_distance. +func (x *TS2Cell) GridDistance(dest *Temporal) (*Temporal, error) { + _r0, _err := functions.Ts2cellGridDistance(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(dest.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/ts2cellinst.go b/types/ts2cellinst.go new file mode 100644 index 0000000..463786d --- /dev/null +++ b/types/ts2cellinst.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 TS2CellInst struct { + handle +} + +// TS2CellInstFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TS2CellInstFromPointer(p unsafe.Pointer) *TS2CellInst { + if p == nil { + return nil + } + v := &TS2CellInst{} + v.ptr = p + return v +} + +// TS2CellInstMake is MEOS ts2cellinst_make. +func TS2CellInstMake(value uint64, t int64) (*Temporal, error) { + _r0, _err := functions.Ts2cellinstMake(value, t) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/ts2cellseq.go b/types/ts2cellseq.go new file mode 100644 index 0000000..883f0e3 --- /dev/null +++ b/types/ts2cellseq.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 TS2CellSeq struct { + handle +} + +// TS2CellSeqFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TS2CellSeqFromPointer(p unsafe.Pointer) *TS2CellSeq { + if p == nil { + return nil + } + v := &TS2CellSeq{} + v.ptr = p + return v +} + +// TS2CellSeqFromBaseTstzset is MEOS ts2cellseq_from_base_tstzset. +func TS2CellSeqFromBaseTstzset(value uint64, s *Set) (*Temporal, error) { + _r0, _err := functions.Ts2cellseqFromBaseTstzset(value, functions.SetFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TS2CellSeqFromBaseTstzspan is MEOS ts2cellseq_from_base_tstzspan. +func TS2CellSeqFromBaseTstzspan(value uint64, s *Span) (*Temporal, error) { + _r0, _err := functions.Ts2cellseqFromBaseTstzspan(value, functions.SpanFromPointer(s.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TS2CellSeqMake is MEOS ts2cellseq_make. +func TS2CellSeqMake(values unsafe.Pointer, times unsafe.Pointer, count int, lower_inc bool, upper_inc bool) (*Temporal, error) { + _r0, _err := functions.Ts2cellseqMake(values, times, count, lower_inc, upper_inc) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/ts2cellseqset.go b/types/ts2cellseqset.go new file mode 100644 index 0000000..52328de --- /dev/null +++ b/types/ts2cellseqset.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 TS2CellSeqSet struct { + handle +} + +// TS2CellSeqSetFromPointer wraps a MEOS pointer, answering nil for nil so an +// absent MEOS result stays absent rather than becoming a live handle. +func TS2CellSeqSetFromPointer(p unsafe.Pointer) *TS2CellSeqSet { + if p == nil { + return nil + } + v := &TS2CellSeqSet{} + v.ptr = p + return v +} + +// TS2CellSeqSetFromBaseTstzspanset is MEOS ts2cellseqset_from_base_tstzspanset. +func TS2CellSeqSetFromBaseTstzspanset(value uint64, ss *SpanSet) (*Temporal, error) { + _r0, _err := functions.Ts2cellseqsetFromBaseTstzspanset(value, functions.SpanSetFromPointer(ss.Pointer())) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// TS2CellSeqSetMake is MEOS ts2cellseqset_make. +func TS2CellSeqSetMake(sequences unsafe.Pointer, count int) (*Temporal, error) { + _r0, _err := functions.Ts2cellseqsetMake(sequences, count) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tspatial.go b/types/tspatial.go index 656de3e..ef73cbf 100644 --- a/types/tspatial.go +++ b/types/tspatial.go @@ -52,8 +52,8 @@ func (x *TSpatial) AsEWKT(maxdd int) (string, error) { return _r0, nil } -// AsHEXEWKB is MEOS tspatial_as_hexewkb. -func (x *TSpatial) AsHEXEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { +// AsHexEWKB is MEOS tspatial_as_hexewkb. +func (x *TSpatial) AsHexEWKB(variant uint8, size_out unsafe.Pointer) (string, error) { _r0, _err := functions.TspatialAsHexewkb(functions.TemporalFromPointer(x.Pointer()), variant, size_out) if _err != nil { return "", _err