From 90a4c6e08b0b1c552e4c9e17f0ec42bd9066675a Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Sat, 15 Aug 2026 14:14:06 +0200 Subject: [PATCH] Ask pkg-config where MEOS is and which families it has The cgo preamble hardcoded /usr/local (and /opt/homebrew) as the place to find libmeos, plus a hand-kept list of ten -D family macros mirroring the if(ALL) loop in MobilityDB's CMakeLists. Both are assumptions about a machine rather than facts about the library, and the -D list is the one that bites: the public headers gate declarations on those macros, so a list that disagrees with the installed library either declares a symbol that cannot link or hides a family the library provides. The macros are not derivable from -DALL either, which selects families at configure time and never reaches a compiler. The installed meos.pc now reports both, so the preamble asks for them. This also makes the binding relocatable: PKG_CONFIG_PATH selects which libmeos to build against, which is what lets a build target a private prefix instead of inheriting a machine-wide directory shared with everything else on the host. H3 ships no pkg-config file, so meos_h3.h's keeps its include dir named here; GEOS and GSL resolve from the default include path. --- functions/cgo.go | 29 +- functions/meos_meos.go | 574 ++++++++++++++++------------ functions/meos_meos_catalog.go | 7 + functions/meos_meos_cbuffer.go | 19 +- functions/meos_meos_geo.go | 21 +- functions/meos_meos_h3.go | 127 ++---- functions/meos_meos_internal.go | 106 +++-- functions/meos_meos_internal_geo.go | 90 ++++- functions/meos_meos_json.go | 47 ++- functions/meos_meos_pointcloud.go | 408 +++++++++++++++++++- functions/meos_meos_pose.go | 19 +- functions/meos_meos_quadbin.go | 184 +++++---- functions/meos_meos_rgeo.go | 173 ++++++++- functions/types.go | 5 + tools/codegen.py | 31 +- 15 files changed, 1296 insertions(+), 544 deletions(-) diff --git a/functions/cgo.go b/functions/cgo.go index a32ab13..9ec333c 100644 --- a/functions/cgo.go +++ b/functions/cgo.go @@ -1,17 +1,26 @@ package functions /* -// Every optional MEOS family is enabled so the ``#if ``-guarded -// declarations in the core headers (e.g. meos_initialize_pointcloud) are -// visible -- matching the all-families libmeos the catalog is derived from, in -// sync with MobilityDB CMakeLists.txt's ``if(ALL)`` loop (alphabetical). The -// families expose external library types (H3's h3api.h) through their own -// headers, so their include dirs are added too. -#cgo darwin CFLAGS: -I/opt/homebrew/include -I/opt/homebrew/include/h3 -DMEOS=1 -DCBUFFER=1 -DH3=1 -DJSON=1 -DNPOINT=1 -DPOINTCLOUD=1 -DPOSE=1 -DQUADBIN=1 -DRASTER=1 -DRGEO=1 -#cgo darwin LDFLAGS: -L/opt/homebrew/lib -lmeos -Wl,-rpath,/opt/homebrew/lib +// The installed libmeos describes itself: `pkg-config --cflags meos` reports +// its include dir together with the family macros it is compiled with, and +// `--libs` reports where to link it from. Both matter, because the public +// headers gate declarations on those macros (meos.h holds #if MEOS, #if +// POINTCLOUD and #if JSON blocks), so a hand-kept -D list that disagrees with +// the library either declares a symbol that cannot link or hides a family the +// library provides. +// +// Asking pkg-config also makes the binding relocatable: PKG_CONFIG_PATH selects +// which libmeos to build against, so a build points at a private prefix rather +// than inheriting whatever occupies a machine-wide directory. A prefix outside +// the loader's default search path needs LD_LIBRARY_PATH (or ldconfig). +#cgo pkg-config: meos -#cgo linux CFLAGS: -I/usr/local/include/ -I/usr/include/h3 -DMEOS=1 -DCBUFFER=1 -DH3=1 -DJSON=1 -DNPOINT=1 -DPOINTCLOUD=1 -DPOSE=1 -DQUADBIN=1 -DRASTER=1 -DRGEO=1 -#cgo linux LDFLAGS: -L/usr/local/lib -lmeos -Wl,-rpath,/usr/local/lib +// H3 ships no pkg-config file, so the one dependency whose header the public +// MEOS headers expose (meos_h3.h includes ) names its include dir +// here. GEOS and GSL, the other exposed dependencies, resolve from the default +// include path. +#cgo darwin CFLAGS: -I/opt/homebrew/include/h3 +#cgo linux CFLAGS: -I/usr/include/h3 #include #include "meos.h" diff --git a/functions/meos_meos.go b/functions/meos_meos.go index cc0ea15..dc34e53 100644 --- a/functions/meos_meos.go +++ b/functions/meos_meos.go @@ -85,231 +85,6 @@ import ( var _ = unsafe.Pointer(nil) -// BoolIn wraps MEOS C function bool_in. -func BoolIn(str string) bool { - _c_str := C.CString(str) - defer C.free(unsafe.Pointer(_c_str)) - _cret := C.bool_in(_c_str) - return bool(_cret) -} - - -// BoolOut wraps MEOS C function bool_out. -func BoolOut(b bool) string { - _cret := C.bool_out(C.bool(b)) - return C.GoString(_cret) -} - - -// Float8Out wraps MEOS C function float8_out. -func Float8Out(num float64, maxdd int) string { - _cret := C.float8_out(C.double(num), C.int(maxdd)) - return C.GoString(_cret) -} - - -// DateIn wraps MEOS C function date_in. -func DateIn(str string) int32 { - _c_str := C.CString(str) - defer C.free(unsafe.Pointer(_c_str)) - _cret := C.date_in(_c_str) - return int32(_cret) -} - - -// DateOut wraps MEOS C function date_out. -func DateOut(date int32) string { - _cret := C.date_out(C.DateADT(date)) - return C.GoString(_cret) -} - - -// IntervalCmp wraps MEOS C function interval_cmp. -func IntervalCmp(interv1 *Interval, interv2 *Interval) int { - _cret := C.interval_cmp(interv1._inner, interv2._inner) - return int(_cret) -} - - -// IntervalIn wraps MEOS C function interval_in. -func IntervalIn(str string, typmod int32) *Interval { - _c_str := C.CString(str) - defer C.free(unsafe.Pointer(_c_str)) - _cret := C.interval_in(_c_str, C.int32(typmod)) - return &Interval{_inner: _cret} -} - - -// IntervalOut wraps MEOS C function interval_out. -func IntervalOut(interv *Interval) string { - _cret := C.interval_out(interv._inner) - return C.GoString(_cret) -} - - -// TimeIn wraps MEOS C function time_in. -func TimeIn(str string, typmod int32) int64 { - _c_str := C.CString(str) - defer C.free(unsafe.Pointer(_c_str)) - _cret := C.time_in(_c_str, C.int32(typmod)) - return int64(_cret) -} - - -// TimeOut wraps MEOS C function time_out. -func TimeOut(time int64) string { - _cret := C.time_out(C.TimeADT(time)) - return C.GoString(_cret) -} - - -// TimestampIn wraps MEOS C function timestamp_in. -func TimestampIn(str string, typmod int32) int64 { - _c_str := C.CString(str) - defer C.free(unsafe.Pointer(_c_str)) - _cret := C.timestamp_in(_c_str, C.int32(typmod)) - return int64(_cret) -} - - -// TimestampOut wraps MEOS C function timestamp_out. -func TimestampOut(ts int64) string { - _cret := C.timestamp_out(C.Timestamp(ts)) - return C.GoString(_cret) -} - - -// TimestamptzIn wraps MEOS C function timestamptz_in. -func TimestamptzIn(str string, typmod int32) int64 { - _c_str := C.CString(str) - defer C.free(unsafe.Pointer(_c_str)) - _cret := C.timestamptz_in(_c_str, C.int32(typmod)) - return int64(_cret) -} - - -// TimestamptzOut wraps MEOS C function timestamptz_out. -func TimestamptzOut(tstz int64) string { - _cret := C.timestamptz_out(C.TimestampTz(tstz)) - return C.GoString(_cret) -} - - -// CstringToText wraps MEOS C function cstring_to_text. -func CstringToText(str string) string { - _c_str := C.CString(str) - defer C.free(unsafe.Pointer(_c_str)) - _cret := C.cstring_to_text(_c_str) - return C.GoString(C.text_to_cstring(_cret)) -} - - -// TextToCstring wraps MEOS C function text_to_cstring. -func TextToCstring(txt string) string { - _c_txt := C.cstring_to_text(C.CString(txt)) - defer C.free(unsafe.Pointer(_c_txt)) - _cret := C.text_to_cstring(_c_txt) - return C.GoString(_cret) -} - - -// TextIn wraps MEOS C function text_in. -func TextIn(str string) string { - _c_str := C.CString(str) - defer C.free(unsafe.Pointer(_c_str)) - _cret := C.text_in(_c_str) - return C.GoString(C.text_to_cstring(_cret)) -} - - -// TextOut wraps MEOS C function text_out. -func TextOut(txt string) string { - _c_txt := C.cstring_to_text(C.CString(txt)) - defer C.free(unsafe.Pointer(_c_txt)) - _cret := C.text_out(_c_txt) - return C.GoString(_cret) -} - - -// TODO text_cmp: unsupported param Oid -// func TextCmp(...) { /* not yet handled by codegen */ } - - -// TextCopy wraps MEOS C function text_copy. -func TextCopy(txt string) string { - _c_txt := C.cstring_to_text(C.CString(txt)) - defer C.free(unsafe.Pointer(_c_txt)) - _cret := C.text_copy(_c_txt) - return C.GoString(C.text_to_cstring(_cret)) -} - - -// TextInitcap wraps MEOS C function text_initcap. -func TextInitcap(txt string) string { - _c_txt := C.cstring_to_text(C.CString(txt)) - defer C.free(unsafe.Pointer(_c_txt)) - _cret := C.text_initcap(_c_txt) - return C.GoString(C.text_to_cstring(_cret)) -} - - -// TextLower wraps MEOS C function text_lower. -func TextLower(txt string) string { - _c_txt := C.cstring_to_text(C.CString(txt)) - defer C.free(unsafe.Pointer(_c_txt)) - _cret := C.text_lower(_c_txt) - return C.GoString(C.text_to_cstring(_cret)) -} - - -// TextUpper wraps MEOS C function text_upper. -func TextUpper(txt string) string { - _c_txt := C.cstring_to_text(C.CString(txt)) - defer C.free(unsafe.Pointer(_c_txt)) - _cret := C.text_upper(_c_txt) - return C.GoString(C.text_to_cstring(_cret)) -} - - -// TextcatTextText wraps MEOS C function textcat_text_text. -func TextcatTextText(txt1 string, txt2 string) string { - _c_txt1 := C.cstring_to_text(C.CString(txt1)) - defer C.free(unsafe.Pointer(_c_txt1)) - _c_txt2 := C.cstring_to_text(C.CString(txt2)) - defer C.free(unsafe.Pointer(_c_txt2)) - _cret := C.textcat_text_text(_c_txt1, _c_txt2) - return C.GoString(C.text_to_cstring(_cret)) -} - - -// MeosErrno wraps MEOS C function meos_errno. -func MeosErrno() int { - _cret := C.meos_errno() - return int(_cret) -} - - -// MeosErrnoSet wraps MEOS C function meos_errno_set. -func MeosErrnoSet(err int) int { - _cret := C.meos_errno_set(C.int(err)) - return int(_cret) -} - - -// MeosErrnoRestore wraps MEOS C function meos_errno_restore. -func MeosErrnoRestore(err int) int { - _cret := C.meos_errno_restore(C.int(err)) - return int(_cret) -} - - -// MeosErrnoReset wraps MEOS C function meos_errno_reset. -func MeosErrnoReset() int { - _cret := C.meos_errno_reset() - return int(_cret) -} - - // MeosArrayCreate wraps MEOS C function meos_array_create. func MeosArrayCreate(elem_size int) *MeosArray { _cret := C.meos_array_create(C.int(elem_size)) @@ -449,6 +224,14 @@ func RtreeSearch(rtree *RTree, op RTreeSearchOp, query unsafe.Pointer) (int, *Me } +// RtreeJoin wraps MEOS C function rtree_join. +func RtreeJoin(rtree1 *RTree, rtree2 *RTree, op RTreeSearchOp) (int, *MeosArray) { + var _out_result C.MeosArray + _cret := C.rtree_join(rtree1._inner, rtree2._inner, C.RTreeSearchOp(op), &_out_result) + return int(_cret), &MeosArray{_inner: &_out_result} +} + + // RtreeSearchTemporal wraps MEOS C function rtree_search_temporal. func RtreeSearchTemporal(rtree *RTree, op RTreeSearchOp, temp *Temporal) (int, *MeosArray) { var _out_result C.MeosArray @@ -465,6 +248,126 @@ func RtreeSearchTemporalDedup(rtree *RTree, op RTreeSearchOp, temp *Temporal, ma } +// RtreeNnCursorOpen wraps MEOS C function rtree_nn_cursor_open. +func RtreeNnCursorOpen(rtree *RTree, query unsafe.Pointer) unsafe.Pointer { + _cret := C.rtree_nn_cursor_open(rtree._inner, unsafe.Pointer(query)) + return unsafe.Pointer(_cret) +} + + +// RtreeNnCursorNext wraps MEOS C function rtree_nn_cursor_next. +func RtreeNnCursorNext(cursor unsafe.Pointer, id_out unsafe.Pointer, dist_out unsafe.Pointer) bool { + _cret := C.rtree_nn_cursor_next((*C.RTreeNNCursor)(unsafe.Pointer(cursor)), (*C.int)(unsafe.Pointer(id_out)), (*C.double)(unsafe.Pointer(dist_out))) + return bool(_cret) +} + + +// RtreeNnCursorClose wraps MEOS C function rtree_nn_cursor_close. +func RtreeNnCursorClose(cursor unsafe.Pointer) { + C.rtree_nn_cursor_close((*C.RTreeNNCursor)(unsafe.Pointer(cursor))) +} + + +// TODO sptree_create_intspan: unsupported param SPTreeKind +// func SptreeCreateIntspan(...) { /* not yet handled by codegen */ } + + +// TODO sptree_create_bigintspan: unsupported param SPTreeKind +// func SptreeCreateBigintspan(...) { /* not yet handled by codegen */ } + + +// TODO sptree_create_floatspan: unsupported param SPTreeKind +// func SptreeCreateFloatspan(...) { /* not yet handled by codegen */ } + + +// TODO sptree_create_datespan: unsupported param SPTreeKind +// func SptreeCreateDatespan(...) { /* not yet handled by codegen */ } + + +// TODO sptree_create_tstzspan: unsupported param SPTreeKind +// func SptreeCreateTstzspan(...) { /* not yet handled by codegen */ } + + +// TODO sptree_create_tbox: unsupported param SPTreeKind +// func SptreeCreateTBOX(...) { /* not yet handled by codegen */ } + + +// TODO sptree_create_stbox: unsupported param SPTreeKind +// func SptreeCreateSTBOX(...) { /* not yet handled by codegen */ } + + +// TODO sptree_create_tpcbox: unsupported param SPTreeKind +// func SptreeCreateTpcbox(...) { /* not yet handled by codegen */ } + + +// SptreeFree wraps MEOS C function sptree_free. +func SptreeFree(sptree unsafe.Pointer) { + C.sptree_free((*C.SPTree)(unsafe.Pointer(sptree))) +} + + +// SptreeInsert wraps MEOS C function sptree_insert. +func SptreeInsert(sptree unsafe.Pointer, box unsafe.Pointer, id int) { + C.sptree_insert((*C.SPTree)(unsafe.Pointer(sptree)), unsafe.Pointer(box), C.int(id)) +} + + +// SptreeInsertTemporal wraps MEOS C function sptree_insert_temporal. +func SptreeInsertTemporal(sptree unsafe.Pointer, temp *Temporal, id int) { + C.sptree_insert_temporal((*C.SPTree)(unsafe.Pointer(sptree)), temp._inner, C.int(id)) +} + + +// SptreeInsertTemporalSplit wraps MEOS C function sptree_insert_temporal_split. +func SptreeInsertTemporalSplit(sptree unsafe.Pointer, temp *Temporal, id int, maxboxes int) { + C.sptree_insert_temporal_split((*C.SPTree)(unsafe.Pointer(sptree)), temp._inner, C.int(id), C.int(maxboxes)) +} + + +// SptreeSearch wraps MEOS C function sptree_search. +func SptreeSearch(sptree unsafe.Pointer, op RTreeSearchOp, query unsafe.Pointer) (int, *MeosArray) { + var _out_result C.MeosArray + _cret := C.sptree_search((*C.SPTree)(unsafe.Pointer(sptree)), C.RTreeSearchOp(op), unsafe.Pointer(query), &_out_result) + return int(_cret), &MeosArray{_inner: &_out_result} +} + + +// SptreeSearchTemporal wraps MEOS C function sptree_search_temporal. +func SptreeSearchTemporal(sptree unsafe.Pointer, op RTreeSearchOp, temp *Temporal) (int, *MeosArray) { + var _out_result C.MeosArray + _cret := C.sptree_search_temporal((*C.SPTree)(unsafe.Pointer(sptree)), C.RTreeSearchOp(op), temp._inner, &_out_result) + return int(_cret), &MeosArray{_inner: &_out_result} +} + + +// SptreeSearchTemporalDedup wraps MEOS C function sptree_search_temporal_dedup. +func SptreeSearchTemporalDedup(sptree unsafe.Pointer, op RTreeSearchOp, temp *Temporal, maxboxes int) (int, *MeosArray) { + var _out_result C.MeosArray + _cret := C.sptree_search_temporal_dedup((*C.SPTree)(unsafe.Pointer(sptree)), C.RTreeSearchOp(op), temp._inner, C.int(maxboxes), &_out_result) + return int(_cret), &MeosArray{_inner: &_out_result} +} + + +// SptreeNnCursorOpen wraps MEOS C function sptree_nn_cursor_open. +func SptreeNnCursorOpen(sptree unsafe.Pointer, query unsafe.Pointer) unsafe.Pointer { + _cret := C.sptree_nn_cursor_open((*C.SPTree)(unsafe.Pointer(sptree)), unsafe.Pointer(query)) + return unsafe.Pointer(_cret) +} + + +// SptreeNnCursorNext wraps MEOS C function sptree_nn_cursor_next. +func SptreeNnCursorNext(cursor unsafe.Pointer, id_out unsafe.Pointer, dist_out unsafe.Pointer) bool { + _cret := C.sptree_nn_cursor_next((*C.SPNNCursor)(unsafe.Pointer(cursor)), (*C.int)(unsafe.Pointer(id_out)), (*C.double)(unsafe.Pointer(dist_out))) + return bool(_cret) +} + + +// SptreeNnCursorClose wraps MEOS C function sptree_nn_cursor_close. +func SptreeNnCursorClose(cursor unsafe.Pointer) { + C.sptree_nn_cursor_close((*C.SPNNCursor)(unsafe.Pointer(cursor))) +} + + // TODO meos_initialize_allocator: unsupported param meos_malloc_fn // func MeosInitializeAllocator(...) { /* not yet handled by codegen */ } @@ -579,6 +482,34 @@ func MeosFinalize() { } +// MeosVersion wraps MEOS C function meos_version. +func MeosVersion() string { + _cret := C.meos_version() + return C.GoString(_cret) +} + + +// MeosFullVersion wraps MEOS C function meos_full_version. +func MeosFullVersion() string { + _cret := C.meos_full_version() + return C.GoString(_cret) +} + + +// MobilitydbVersion wraps MEOS C function mobilitydb_version. +func MobilitydbVersion() string { + _cret := C.mobilitydb_version() + return C.GoString(_cret) +} + + +// MobilitydbFullVersion wraps MEOS C function mobilitydb_full_version. +func MobilitydbFullVersion() string { + _cret := C.mobilitydb_full_version() + return C.GoString(_cret) +} + + // BigintsetIn wraps MEOS C function bigintset_in. func BigintsetIn(str string) *Set { _c_str := C.CString(str) @@ -1448,6 +1379,13 @@ func DatespansetEndDate(ss *SpanSet) int32 { } +// DatespansetLower wraps MEOS C function datespanset_lower. +func DatespansetLower(ss *SpanSet) int32 { + _cret := C.datespanset_lower(ss._inner) + return int32(_cret) +} + + // DatespansetNumDates wraps MEOS C function datespanset_num_dates. func DatespansetNumDates(ss *SpanSet) int { _cret := C.datespanset_num_dates(ss._inner) @@ -1462,6 +1400,13 @@ func DatespansetStartDate(ss *SpanSet) int32 { } +// DatespansetUpper wraps MEOS C function datespanset_upper. +func DatespansetUpper(ss *SpanSet) int32 { + _cret := C.datespanset_upper(ss._inner) + return int32(_cret) +} + + // FloatsetEndValue wraps MEOS C function floatset_end_value. func FloatsetEndValue(s *Set) float64 { _cret := C.floatset_end_value(s._inner) @@ -2381,6 +2326,41 @@ func AdjacentSpanTimestamptz(s *Span, t int64) bool { } +// AdjacentBigintSpan wraps MEOS C function adjacent_bigint_span. +func AdjacentBigintSpan(i int64, s *Span) bool { + _cret := C.adjacent_bigint_span(C.int64_t(i), s._inner) + return bool(_cret) +} + + +// AdjacentDateSpan wraps MEOS C function adjacent_date_span. +func AdjacentDateSpan(d int32, s *Span) bool { + _cret := C.adjacent_date_span(C.DateADT(d), s._inner) + return bool(_cret) +} + + +// AdjacentFloatSpan wraps MEOS C function adjacent_float_span. +func AdjacentFloatSpan(d float64, s *Span) bool { + _cret := C.adjacent_float_span(C.double(d), s._inner) + return bool(_cret) +} + + +// AdjacentIntSpan wraps MEOS C function adjacent_int_span. +func AdjacentIntSpan(i int, s *Span) bool { + _cret := C.adjacent_int_span(C.int(i), s._inner) + return bool(_cret) +} + + +// AdjacentTimestamptzSpan wraps MEOS C function adjacent_timestamptz_span. +func AdjacentTimestamptzSpan(t int64, s *Span) bool { + _cret := C.adjacent_timestamptz_span(C.TimestampTz(t), s._inner) + return bool(_cret) +} + + // AdjacentSpansetBigint wraps MEOS C function adjacent_spanset_bigint. func AdjacentSpansetBigint(ss *SpanSet, i int64) bool { _cret := C.adjacent_spanset_bigint(ss._inner, C.int64_t(i)) @@ -4286,8 +4266,8 @@ func UnionBigintSet(i int64, s *Set) *Set { // UnionBigintSpan wraps MEOS C function union_bigint_span. -func UnionBigintSpan(s *Span, i int64) *SpanSet { - _cret := C.gunion_bigint_span(s._inner, C.int64_t(i)) +func UnionBigintSpan(i int64, s *Span) *SpanSet { + _cret := C.gunion_bigint_span(C.int64_t(i), s._inner) return &SpanSet{_inner: _cret} } @@ -4307,8 +4287,8 @@ func UnionDateSet(d int32, s *Set) *Set { // UnionDateSpan wraps MEOS C function union_date_span. -func UnionDateSpan(s *Span, d int32) *SpanSet { - _cret := C.gunion_date_span(s._inner, C.DateADT(d)) +func UnionDateSpan(d int32, s *Span) *SpanSet { + _cret := C.gunion_date_span(C.DateADT(d), s._inner) return &SpanSet{_inner: _cret} } @@ -4328,8 +4308,8 @@ func UnionFloatSet(d float64, s *Set) *Set { // UnionFloatSpan wraps MEOS C function union_float_span. -func UnionFloatSpan(s *Span, d float64) *SpanSet { - _cret := C.gunion_float_span(s._inner, C.double(d)) +func UnionFloatSpan(d float64, s *Span) *SpanSet { + _cret := C.gunion_float_span(C.double(d), s._inner) return &SpanSet{_inner: _cret} } @@ -4448,13 +4428,6 @@ func UnionSpanSpan(s1 *Span, s2 *Span) *SpanSet { } -// SuperUnionSpanSpan wraps MEOS C function super_union_span_span. -func SuperUnionSpanSpan(s1 *Span, s2 *Span) *Span { - _cret := C.super_union_span_span(s1._inner, s2._inner) - return &Span{_inner: _cret} -} - - // UnionSpanSpanset wraps MEOS C function union_span_spanset. func UnionSpanSpanset(s *Span, ss *SpanSet) *SpanSet { _cret := C.gunion_span_spanset(s._inner, ss._inner) @@ -5631,6 +5604,15 @@ func TemporalAsWKB(temp *Temporal, variant uint8, size_out unsafe.Pointer) unsaf } +// WKBVariantFromEndian wraps MEOS C function wkb_variant_from_endian. +func WKBVariantFromEndian(endian string) uint8 { + _c_endian := C.CString(endian) + defer C.free(unsafe.Pointer(_c_endian)) + _cret := C.wkb_variant_from_endian(_c_endian) + return uint8(_cret) +} + + // TemporalFromHexwkb wraps MEOS C function temporal_from_hexwkb. func TemporalFromHexwkb(hexwkb string) *Temporal { _c_hexwkb := C.CString(hexwkb) @@ -6102,6 +6084,13 @@ func TemporalHash(temp *Temporal) uint32 { } +// TemporalHashExtended wraps MEOS C function temporal_hash_extended. +func TemporalHashExtended(temp *Temporal, seed uint64) uint64 { + _cret := C.temporal_hash_extended(temp._inner, C.uint64_t(seed)) + return uint64(_cret) +} + + // TemporalInstantN wraps MEOS C function temporal_instant_n. func TemporalInstantN(temp *Temporal, n int) *TInstant { _cret := C.temporal_instant_n(temp._inner, C.int(n)) @@ -6545,23 +6534,23 @@ func TemporalShiftTime(temp *Temporal, shift *Interval) *Temporal { } -// TemporalToTinstant wraps MEOS C function temporal_to_tinstant. -func TemporalToTinstant(temp *Temporal) *TInstant { - _cret := C.temporal_to_tinstant(temp._inner) +// TemporalAsTinstant wraps MEOS C function temporal_as_tinstant. +func TemporalAsTinstant(temp *Temporal) *TInstant { + _cret := C.temporal_as_tinstant(temp._inner) return &TInstant{_inner: _cret} } -// TemporalToTsequence wraps MEOS C function temporal_to_tsequence. -func TemporalToTsequence(temp *Temporal, interp Interpolation) *TSequence { - _cret := C.temporal_to_tsequence(temp._inner, C.interpType(interp)) +// TemporalAsTsequence wraps MEOS C function temporal_as_tsequence. +func TemporalAsTsequence(temp *Temporal, interp Interpolation) *TSequence { + _cret := C.temporal_as_tsequence(temp._inner, C.interpType(interp)) return &TSequence{_inner: _cret} } -// TemporalToTsequenceset wraps MEOS C function temporal_to_tsequenceset. -func TemporalToTsequenceset(temp *Temporal, interp Interpolation) *TSequenceSet { - _cret := C.temporal_to_tsequenceset(temp._inner, C.interpType(interp)) +// TemporalAsTsequenceset wraps MEOS C function temporal_as_tsequenceset. +func TemporalAsTsequenceset(temp *Temporal, interp Interpolation) *TSequenceSet { + _cret := C.temporal_as_tsequenceset(temp._inner, C.interpType(interp)) return &TSequenceSet{_inner: _cret} } @@ -9264,6 +9253,34 @@ func NadTfloatTBOX(temp *Temporal, box *TBox) float64 { } +// NadTbigintBigint wraps MEOS C function nad_tbigint_bigint. +func NadTbigintBigint(temp *Temporal, i int64) int64 { + _cret := C.nad_tbigint_bigint(temp._inner, C.int64_t(i)) + return int64(_cret) +} + + +// NadTbigintTBOX wraps MEOS C function nad_tbigint_tbox. +func NadTbigintTBOX(temp *Temporal, box *TBox) int64 { + _cret := C.nad_tbigint_tbox(temp._inner, box._inner) + return int64(_cret) +} + + +// NadTbigintTbigint wraps MEOS C function nad_tbigint_tbigint. +func NadTbigintTbigint(temp1 *Temporal, temp2 *Temporal) int64 { + _cret := C.nad_tbigint_tbigint(temp1._inner, temp2._inner) + return int64(_cret) +} + + +// NadTboxbigintTboxbigint wraps MEOS C function nad_tboxbigint_tboxbigint. +func NadTboxbigintTboxbigint(box1 *TBox, box2 *TBox) int64 { + _cret := C.nad_tboxbigint_tboxbigint(box1._inner, box2._inner) + return int64(_cret) +} + + // NadTintInt wraps MEOS C function nad_tint_int. func NadTintInt(temp *Temporal, i int) int { _cret := C.nad_tint_int(temp._inner, C.int(i)) @@ -9285,6 +9302,69 @@ func NadTintTint(temp1 *Temporal, temp2 *Temporal) int { } +// TbigintTmaxTransfn wraps MEOS C function tbigint_tmax_transfn. +func TbigintTmaxTransfn(state *SkipList, temp *Temporal) *SkipList { + _cret := C.tbigint_tmax_transfn(state._inner, temp._inner) + return &SkipList{_inner: _cret} +} + + +// TbigintTmaxCombinefn wraps MEOS C function tbigint_tmax_combinefn. +func TbigintTmaxCombinefn(state1 *SkipList, state2 *SkipList) *SkipList { + _cret := C.tbigint_tmax_combinefn(state1._inner, state2._inner) + return &SkipList{_inner: _cret} +} + + +// TbigintTminTransfn wraps MEOS C function tbigint_tmin_transfn. +func TbigintTminTransfn(state *SkipList, temp *Temporal) *SkipList { + _cret := C.tbigint_tmin_transfn(state._inner, temp._inner) + return &SkipList{_inner: _cret} +} + + +// TbigintTminCombinefn wraps MEOS C function tbigint_tmin_combinefn. +func TbigintTminCombinefn(state1 *SkipList, state2 *SkipList) *SkipList { + _cret := C.tbigint_tmin_combinefn(state1._inner, state2._inner) + return &SkipList{_inner: _cret} +} + + +// TbigintTsumTransfn wraps MEOS C function tbigint_tsum_transfn. +func TbigintTsumTransfn(state *SkipList, temp *Temporal) *SkipList { + _cret := C.tbigint_tsum_transfn(state._inner, temp._inner) + return &SkipList{_inner: _cret} +} + + +// TbigintTsumCombinefn wraps MEOS C function tbigint_tsum_combinefn. +func TbigintTsumCombinefn(state1 *SkipList, state2 *SkipList) *SkipList { + _cret := C.tbigint_tsum_combinefn(state1._inner, state2._inner) + return &SkipList{_inner: _cret} +} + + +// TbigintWmaxTransfn wraps MEOS C function tbigint_wmax_transfn. +func TbigintWmaxTransfn(state *SkipList, temp *Temporal, interv *Interval) *SkipList { + _cret := C.tbigint_wmax_transfn(state._inner, temp._inner, interv._inner) + return &SkipList{_inner: _cret} +} + + +// TbigintWminTransfn wraps MEOS C function tbigint_wmin_transfn. +func TbigintWminTransfn(state *SkipList, temp *Temporal, interv *Interval) *SkipList { + _cret := C.tbigint_wmin_transfn(state._inner, temp._inner, interv._inner) + return &SkipList{_inner: _cret} +} + + +// TbigintWsumTransfn wraps MEOS C function tbigint_wsum_transfn. +func TbigintWsumTransfn(state *SkipList, temp *Temporal, interv *Interval) *SkipList { + _cret := C.tbigint_wsum_transfn(state._inner, temp._inner, interv._inner) + return &SkipList{_inner: _cret} +} + + // TboolTandTransfn wraps MEOS C function tbool_tand_transfn. func TboolTandTransfn(state *SkipList, temp *Temporal) *SkipList { _cret := C.tbool_tand_transfn(state._inner, temp._inner) diff --git a/functions/meos_meos_catalog.go b/functions/meos_meos_catalog.go index 6307803..cab1e2b 100644 --- a/functions/meos_meos_catalog.go +++ b/functions/meos_meos_catalog.go @@ -359,6 +359,13 @@ func TpointcloudTemptype(type_ MeosType) bool { } +// EnsureTpointcloudTemptype wraps MEOS C function ensure_tpointcloud_temptype. +func EnsureTpointcloudTemptype(type_ MeosType) bool { + _cret := C.ensure_tpointcloud_temptype(C.MeosType(type_)) + return bool(_cret) +} + + // SpanBasetype wraps MEOS C function span_basetype. func SpanBasetype(type_ MeosType) bool { _cret := C.span_basetype(C.MeosType(type_)) diff --git a/functions/meos_meos_cbuffer.go b/functions/meos_meos_cbuffer.go index 66ad539..e7fb340 100644 --- a/functions/meos_meos_cbuffer.go +++ b/functions/meos_meos_cbuffer.go @@ -230,8 +230,9 @@ func CbufferarrRound(cbarr unsafe.Pointer, count int, maxdd int) unsafe.Pointer // CbufferSetSRID wraps MEOS C function cbuffer_set_srid. -func CbufferSetSRID(cb *Cbuffer, srid int32) { - C.cbuffer_set_srid(cb._inner, C.int32_t(srid)) +func CbufferSetSRID(cb *Cbuffer, srid int32) *Cbuffer { + _cret := C.cbuffer_set_srid(cb._inner, C.int32_t(srid)) + return &Cbuffer{_inner: _cret} } @@ -960,6 +961,13 @@ func AcontainsTcbufferGeo(temp *Temporal, gs *Geom) int { } +// AcontainsTcbufferTcbuffer wraps MEOS C function acontains_tcbuffer_tcbuffer. +func AcontainsTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) int { + _cret := C.acontains_tcbuffer_tcbuffer(temp1._inner, temp2._inner) + return int(_cret) +} + + // AcoversCbufferTcbuffer wraps MEOS C function acovers_cbuffer_tcbuffer. func AcoversCbufferTcbuffer(cb *Cbuffer, temp *Temporal) int { _cret := C.acovers_cbuffer_tcbuffer(cb._inner, temp._inner) @@ -1100,6 +1108,13 @@ func EcontainsTcbufferGeo(temp *Temporal, gs *Geom) int { } +// EcontainsTcbufferTcbuffer wraps MEOS C function econtains_tcbuffer_tcbuffer. +func EcontainsTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) int { + _cret := C.econtains_tcbuffer_tcbuffer(temp1._inner, temp2._inner) + return int(_cret) +} + + // EcoversCbufferTcbuffer wraps MEOS C function ecovers_cbuffer_tcbuffer. func EcoversCbufferTcbuffer(cb *Cbuffer, temp *Temporal) int { _cret := C.ecovers_cbuffer_tcbuffer(cb._inner, temp._inner) diff --git a/functions/meos_meos_geo.go b/functions/meos_meos_geo.go index 93878b2..74c3cc7 100644 --- a/functions/meos_meos_geo.go +++ b/functions/meos_meos_geo.go @@ -85,13 +85,6 @@ import ( var _ = unsafe.Pointer(nil) -// Box3dFromGbox wraps MEOS C function box3d_from_gbox. -func Box3dFromGbox(box *GBox) *Box3D { - _cret := C.box3d_from_gbox(box._inner) - return &Box3D{_inner: _cret} -} - - // Box3dMake wraps MEOS C function box3d_make. func Box3dMake(xmin float64, xmax float64, ymin float64, ymax float64, zmin float64, zmax float64, srid int32) *Box3D { _cret := C.box3d_make(C.double(xmin), C.double(xmax), C.double(ymin), C.double(ymax), C.double(zmin), C.double(zmax), C.int32_t(srid)) @@ -2754,6 +2747,13 @@ func AtouchesTpointGeo(temp *Temporal, gs *Geom) int { } +// AtouchesGeoTpoint wraps MEOS C function atouches_geo_tpoint. +func AtouchesGeoTpoint(gs *Geom, temp *Temporal) int { + _cret := C.atouches_geo_tpoint(gs._inner, temp._inner) + return int(_cret) +} + + // EcontainsGeoTgeo wraps MEOS C function econtains_geo_tgeo. func EcontainsGeoTgeo(gs *Geom, temp *Temporal) int { _cret := C.econtains_geo_tgeo(gs._inner, temp._inner) @@ -2887,6 +2887,13 @@ func EtouchesTpointGeo(temp *Temporal, gs *Geom) int { } +// EtouchesGeoTpoint wraps MEOS C function etouches_geo_tpoint. +func EtouchesGeoTpoint(gs *Geom, temp *Temporal) int { + _cret := C.etouches_geo_tpoint(gs._inner, temp._inner) + return int(_cret) +} + + // TcontainsGeoTgeo wraps MEOS C function tcontains_geo_tgeo. func TcontainsGeoTgeo(gs *Geom, temp *Temporal) *Temporal { _cret := C.tcontains_geo_tgeo(gs._inner, temp._inner) diff --git a/functions/meos_meos_h3.go b/functions/meos_meos_h3.go index a6925ca..9ac9370 100644 --- a/functions/meos_meos_h3.go +++ b/functions/meos_meos_h3.go @@ -85,22 +85,6 @@ import ( var _ = unsafe.Pointer(nil) -// H3indexIn wraps MEOS C function h3index_in. -func H3indexIn(str string) uint64 { - _c_str := C.CString(str) - defer C.free(unsafe.Pointer(_c_str)) - _cret := C.h3index_in(_c_str) - return uint64(_cret) -} - - -// H3indexOut wraps MEOS C function h3index_out. -func H3indexOut(cell uint64) string { - _cret := C.h3index_out(C.uint64_t(cell)) - return C.GoString(_cret) -} - - // H3indexFromWKB wraps MEOS C function h3index_from_wkb. func H3indexFromWKB(wkb unsafe.Pointer, size uint) uint64 { _cret := C.h3index_from_wkb((*C.uint8_t)(unsafe.Pointer(wkb)), C.size_t(size)) @@ -131,90 +115,6 @@ func H3indexAsHexwkb(cell uint64, variant uint8, size_out unsafe.Pointer) string } -// H3indexEq wraps MEOS C function h3index_eq. -func H3indexEq(a uint64, b uint64) bool { - _cret := C.h3index_eq(C.uint64_t(a), C.uint64_t(b)) - return bool(_cret) -} - - -// H3indexNe wraps MEOS C function h3index_ne. -func H3indexNe(a uint64, b uint64) bool { - _cret := C.h3index_ne(C.uint64_t(a), C.uint64_t(b)) - return bool(_cret) -} - - -// H3indexLt wraps MEOS C function h3index_lt. -func H3indexLt(a uint64, b uint64) bool { - _cret := C.h3index_lt(C.uint64_t(a), C.uint64_t(b)) - return bool(_cret) -} - - -// H3indexLe wraps MEOS C function h3index_le. -func H3indexLe(a uint64, b uint64) bool { - _cret := C.h3index_le(C.uint64_t(a), C.uint64_t(b)) - return bool(_cret) -} - - -// H3indexGt wraps MEOS C function h3index_gt. -func H3indexGt(a uint64, b uint64) bool { - _cret := C.h3index_gt(C.uint64_t(a), C.uint64_t(b)) - return bool(_cret) -} - - -// H3indexGe wraps MEOS C function h3index_ge. -func H3indexGe(a uint64, b uint64) bool { - _cret := C.h3index_ge(C.uint64_t(a), C.uint64_t(b)) - return bool(_cret) -} - - -// H3indexCmp wraps MEOS C function h3index_cmp. -func H3indexCmp(a uint64, b uint64) int { - _cret := C.h3index_cmp(C.uint64_t(a), C.uint64_t(b)) - return int(_cret) -} - - -// H3indexHash wraps MEOS C function h3index_hash. -func H3indexHash(cell uint64) uint32 { - _cret := C.h3index_hash(C.uint64_t(cell)) - return uint32(_cret) -} - - -// H3GridDisk wraps MEOS C function h3_grid_disk. -func H3GridDisk(origin uint64, k int) *Set { - _cret := C.h3_grid_disk(C.uint64_t(origin), C.int(k)) - return &Set{_inner: _cret} -} - - -// H3CellToChildren wraps MEOS C function h3_cell_to_children. -func H3CellToChildren(origin uint64, childRes int) *Set { - _cret := C.h3_cell_to_children(C.uint64_t(origin), C.int(childRes)) - return &Set{_inner: _cret} -} - - -// H3CompactCells wraps MEOS C function h3_compact_cells. -func H3CompactCells(cells *Set) *Set { - _cret := C.h3_compact_cells(cells._inner) - return &Set{_inner: _cret} -} - - -// H3UncompactCells wraps MEOS C function h3_uncompact_cells. -func H3UncompactCells(cells *Set, res int) *Set { - _cret := C.h3_uncompact_cells(cells._inner, C.int(res)) - return &Set{_inner: _cret} -} - - // Th3indexIn wraps MEOS C function th3index_in. func Th3indexIn(str string) *Temporal { _c_str := C.CString(str) @@ -568,9 +468,9 @@ func Th3indexCellToBoundary(temp *Temporal) *Temporal { } -// H3GsPointToCell wraps MEOS C function h3_gs_point_to_cell. -func H3GsPointToCell(point *Geom, resolution int32) uint64 { - _cret := C.h3_gs_point_to_cell(point._inner, C.int32(resolution)) +// GeoToH3indexCell wraps MEOS C function geo_to_h3index_cell. +func GeoToH3indexCell(point *Geom, resolution int32) uint64 { + _cret := C.geo_to_h3index_cell(point._inner, C.int32(resolution)) return uint64(_cret) } @@ -582,6 +482,27 @@ func GeoToH3indexSet(gs *Geom, resolution int32) *Set { } +// H3indexToSTBOX wraps MEOS C function h3index_to_stbox. +func H3indexToSTBOX(cell uint64) *STBox { + _cret := C.h3index_to_stbox(C.uint64_t(cell)) + return &STBox{_inner: _cret} +} + + +// H3indexTimestamptzToSTBOX wraps MEOS C function h3index_timestamptz_to_stbox. +func H3indexTimestamptzToSTBOX(cell uint64, t int64) *STBox { + _cret := C.h3index_timestamptz_to_stbox(C.uint64_t(cell), C.TimestampTz(t)) + return &STBox{_inner: _cret} +} + + +// H3indexTstzspanToSTBOX wraps MEOS C function h3index_tstzspan_to_stbox. +func H3indexTstzspanToSTBOX(cell uint64, s *Span) *STBox { + _cret := C.h3index_tstzspan_to_stbox(C.uint64_t(cell), s._inner) + return &STBox{_inner: _cret} +} + + // EverEqH3indexsetTh3index wraps MEOS C function ever_eq_h3indexset_th3index. func EverEqH3indexsetTh3index(cells *Set, th3idx *Temporal) int { _cret := C.ever_eq_h3indexset_th3index(cells._inner, th3idx._inner) diff --git a/functions/meos_meos_internal.go b/functions/meos_meos_internal.go index 637380b..d8dd254 100644 --- a/functions/meos_meos_internal.go +++ b/functions/meos_meos_internal.go @@ -275,6 +275,13 @@ func SpanExpand(s1 *Span, s2 *Span) { } +// SuperUnionSpanSpan wraps MEOS C function super_union_span_span. +func SuperUnionSpanSpan(s1 *Span, s2 *Span) *Span { + _cret := C.super_union_span_span(s1._inner, s2._inner) + return &Span{_inner: _cret} +} + + // SpansetCompact wraps MEOS C function spanset_compact. func SpansetCompact(ss *SpanSet) *SpanSet { _cret := C.spanset_compact(ss._inner) @@ -346,6 +353,20 @@ func TemporalBboxCmp(box1 unsafe.Pointer, box2 unsafe.Pointer, temptype MeosType } +// EnsureBboxTemporalCompatible wraps MEOS C function ensure_bbox_temporal_compatible. +func EnsureBboxTemporalCompatible(bboxtype MeosType, temp *Temporal) bool { + _cret := C.ensure_bbox_temporal_compatible(C.MeosType(bboxtype), temp._inner) + return bool(_cret) +} + + +// BboxTemporalSplitBoxes wraps MEOS C function bbox_temporal_split_boxes. +func BboxTemporalSplitBoxes(bboxtype MeosType, boxsize uint, temp *Temporal, maxboxes int, count unsafe.Pointer) unsafe.Pointer { + _cret := C.bbox_temporal_split_boxes(C.MeosType(bboxtype), C.size_t(boxsize), temp._inner, C.int(maxboxes), (*C.int)(unsafe.Pointer(count))) + return unsafe.Pointer(_cret) +} + + // BboxUnionSpanSpan wraps MEOS C function bbox_union_span_span. func BboxUnionSpanSpan(s1 *Span, s2 *Span) *Span { var _out_result C.Span @@ -700,6 +721,13 @@ func TemporalSetTstzspan(temp *Temporal, s *Span) { } +// TemporalTimeOverlaps wraps MEOS C function temporal_time_overlaps. +func TemporalTimeOverlaps(temp1 *Temporal, temp2 *Temporal) bool { + _cret := C.temporal_time_overlaps(temp1._inner, temp2._inner) + return bool(_cret) +} + + // TinstantSetTstzspan wraps MEOS C function tinstant_set_tstzspan. func TinstantSetTstzspan(inst *TInstant, s *Span) { C.tinstant_set_tstzspan(inst._inner, s._inner) @@ -811,6 +839,13 @@ func TinstantHash(inst *TInstant) uint32 { } +// TinstantHashExtended wraps MEOS C function tinstant_hash_extended. +func TinstantHashExtended(inst *TInstant, seed uint64) uint64 { + _cret := C.tinstant_hash_extended(inst._inner, C.uint64_t(seed)) + return uint64(_cret) +} + + // TinstantInsts wraps MEOS C function tinstant_insts. func TinstantInsts(inst *TInstant, count unsafe.Pointer) unsafe.Pointer { _cret := C.tinstant_insts(inst._inner, (*C.int)(unsafe.Pointer(count))) @@ -900,6 +935,13 @@ func TsequenceHash(seq *TSequence) uint32 { } +// TsequenceHashExtended wraps MEOS C function tsequence_hash_extended. +func TsequenceHashExtended(seq *TSequence, seed uint64) uint64 { + _cret := C.tsequence_hash_extended(seq._inner, C.uint64_t(seed)) + return uint64(_cret) +} + + // TsequenceInstsP wraps MEOS C function tsequence_insts_p. func TsequenceInstsP(seq *TSequence, count unsafe.Pointer) unsafe.Pointer { _cret := C.tsequence_insts_p(seq._inner, (*C.int)(unsafe.Pointer(count))) @@ -977,6 +1019,13 @@ func TsequencesetHash(ss *TSequenceSet) uint32 { } +// TsequencesetHashExtended wraps MEOS C function tsequenceset_hash_extended. +func TsequencesetHashExtended(ss *TSequenceSet, seed uint64) uint64 { + _cret := C.tsequenceset_hash_extended(ss._inner, C.uint64_t(seed)) + return uint64(_cret) +} + + // TsequencesetInstN wraps MEOS C function tsequenceset_inst_n. func TsequencesetInstN(ss *TSequenceSet, n int) *TInstant { _cret := C.tsequenceset_inst_n(ss._inner, C.int(n)) @@ -1089,9 +1138,9 @@ func TinstantShiftTime(inst *TInstant, interv *Interval) *TInstant { } -// TinstantToTsequence wraps MEOS C function tinstant_to_tsequence. -func TinstantToTsequence(inst *TInstant, interp Interpolation) *TSequence { - _cret := C.tinstant_to_tsequence(inst._inner, C.interpType(interp)) +// TinstantAsTsequence wraps MEOS C function tinstant_as_tsequence. +func TinstantAsTsequence(inst *TInstant, interp Interpolation) *TSequence { + _cret := C.tinstant_as_tsequence(inst._inner, C.interpType(interp)) return &TSequence{_inner: _cret} } @@ -1103,9 +1152,9 @@ func TinstantToTsequenceFree(inst *TInstant, interp Interpolation) *TSequence { } -// TinstantToTsequenceset wraps MEOS C function tinstant_to_tsequenceset. -func TinstantToTsequenceset(inst *TInstant, interp Interpolation) *TSequenceSet { - _cret := C.tinstant_to_tsequenceset(inst._inner, C.interpType(interp)) +// TinstantAsTsequenceset wraps MEOS C function tinstant_as_tsequenceset. +func TinstantAsTsequenceset(inst *TInstant, interp Interpolation) *TSequenceSet { + _cret := C.tinstant_as_tsequenceset(inst._inner, C.interpType(interp)) return &TSequenceSet{_inner: _cret} } @@ -1137,16 +1186,16 @@ func TsequenceSubseq(seq *TSequence, from int, to int, lower_inc bool, upper_inc } -// TsequenceToTinstant wraps MEOS C function tsequence_to_tinstant. -func TsequenceToTinstant(seq *TSequence) *TInstant { - _cret := C.tsequence_to_tinstant(seq._inner) +// TsequenceAsTinstant wraps MEOS C function tsequence_as_tinstant. +func TsequenceAsTinstant(seq *TSequence) *TInstant { + _cret := C.tsequence_as_tinstant(seq._inner) return &TInstant{_inner: _cret} } -// TsequenceToTsequenceset wraps MEOS C function tsequence_to_tsequenceset. -func TsequenceToTsequenceset(seq *TSequence) *TSequenceSet { - _cret := C.tsequence_to_tsequenceset(seq._inner) +// TsequenceAsTsequenceset wraps MEOS C function tsequence_as_tsequenceset. +func TsequenceAsTsequenceset(seq *TSequence) *TSequenceSet { + _cret := C.tsequence_as_tsequenceset(seq._inner) return &TSequenceSet{_inner: _cret} } @@ -1206,16 +1255,16 @@ func TsequencesetToStep(ss *TSequenceSet) *TSequenceSet { } -// TsequencesetToTinstant wraps MEOS C function tsequenceset_to_tinstant. -func TsequencesetToTinstant(ss *TSequenceSet) *TInstant { - _cret := C.tsequenceset_to_tinstant(ss._inner) +// TsequencesetAsTinstant wraps MEOS C function tsequenceset_as_tinstant. +func TsequencesetAsTinstant(ss *TSequenceSet) *TInstant { + _cret := C.tsequenceset_as_tinstant(ss._inner) return &TInstant{_inner: _cret} } -// TsequencesetToTsequence wraps MEOS C function tsequenceset_to_tsequence. -func TsequencesetToTsequence(ss *TSequenceSet) *TSequence { - _cret := C.tsequenceset_to_tsequence(ss._inner) +// TsequencesetAsTsequence wraps MEOS C function tsequenceset_as_tsequence. +func TsequencesetAsTsequence(ss *TSequenceSet) *TSequence { + _cret := C.tsequenceset_as_tsequence(ss._inner) return &TSequence{_inner: _cret} } @@ -1741,27 +1790,6 @@ func TnumberseqsetDeltaValue(ss *TSequenceSet) *TSequenceSet { } -// NadTBOXTBOX wraps MEOS C function nad_tbox_tbox. -func NadTBOXTBOX(box1 *TBox, box2 *TBox) float64 { - _cret := C.nad_tbox_tbox(box1._inner, box2._inner) - return float64(_cret) -} - - -// NadTnumberTBOX wraps MEOS C function nad_tnumber_tbox. -func NadTnumberTBOX(temp *Temporal, box *TBox) float64 { - _cret := C.nad_tnumber_tbox(temp._inner, box._inner) - return float64(_cret) -} - - -// NadTnumberTnumber wraps MEOS C function nad_tnumber_tnumber. -func NadTnumberTnumber(temp1 *Temporal, temp2 *Temporal) float64 { - _cret := C.nad_tnumber_tnumber(temp1._inner, temp2._inner) - return float64(_cret) -} - - // TnumberseqIntegral wraps MEOS C function tnumberseq_integral. func TnumberseqIntegral(seq *TSequence) float64 { _cret := C.tnumberseq_integral(seq._inner) diff --git a/functions/meos_meos_internal_geo.go b/functions/meos_meos_internal_geo.go index fcff8b2..feef940 100644 --- a/functions/meos_meos_internal_geo.go +++ b/functions/meos_meos_internal_geo.go @@ -99,6 +99,12 @@ func PointRound(gs *Geom, maxdd int) *Geom { } +// GeoSetSRIDInt wraps MEOS C function geo_set_srid_int. +func GeoSetSRIDInt(gs *Geom, srid int32) { + C.geo_set_srid_int(gs._inner, C.int32_t(srid)) +} + + // 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) *STBox { var _out_result C.STBox @@ -155,6 +161,14 @@ func TstzsetSetSTBOX(s *Set) *STBox { } +// TimestamptzSetSTBOX wraps MEOS C function timestamptz_set_stbox. +func TimestamptzSetSTBOX(t int64) *STBox { + var _out_result C.STBox + C.timestamptz_set_stbox(C.TimestampTz(t), &_out_result) + return &STBox{_inner: &_out_result} +} + + // TstzspanSetSTBOX wraps MEOS C function tstzspan_set_stbox. func TstzspanSetSTBOX(s *Span) *STBox { var _out_result C.STBox @@ -177,18 +191,19 @@ func STBOXExpand(box1 *STBox, box2 *STBox) { } -// InterSTBOXSTBOX wraps MEOS C function inter_stbox_stbox. -func InterSTBOXSTBOX(box1 *STBox, box2 *STBox) (bool, *STBox) { +// STBOXExpandSpaceSet wraps MEOS C function stbox_expand_space_set. +func STBOXExpandSpaceSet(box *STBox, d float64) (bool, *STBox) { var _out_result C.STBox - _cret := C.inter_stbox_stbox(box1._inner, box2._inner, &_out_result) + _cret := C.stbox_expand_space_set(box._inner, C.double(d), &_out_result) return bool(_cret), &STBox{_inner: &_out_result} } -// STBOXGeo wraps MEOS C function stbox_geo. -func STBOXGeo(box *STBox) *Geom { - _cret := C.stbox_geo(box._inner) - return &Geom{_inner: _cret} +// InterSTBOXSTBOX wraps MEOS C function inter_stbox_stbox. +func InterSTBOXSTBOX(box1 *STBox, box2 *STBox) (bool, *STBox) { + var _out_result C.STBox + _cret := C.inter_stbox_stbox(box1._inner, box2._inner, &_out_result) + return bool(_cret), &STBox{_inner: &_out_result} } @@ -308,12 +323,6 @@ func TspatialSetSTBOX(temp *Temporal) *STBox { } -// TgeoinstSetSTBOX wraps MEOS C function tgeoinst_set_stbox. -func TgeoinstSetSTBOX(inst *TInstant, box *STBox) { - C.tgeoinst_set_stbox(inst._inner, box._inner) -} - - // TspatialseqSetSTBOX wraps MEOS C function tspatialseq_set_stbox. func TspatialseqSetSTBOX(seq *TSequence, box *STBox) { C.tspatialseq_set_stbox(seq._inner, box._inner) @@ -389,6 +398,40 @@ func TgeoseqsetRestrictSTBOX(ss *TSequenceSet, box *STBox, border_inc bool, atfu } +// GeoClipCtxMake wraps MEOS C function geo_clip_ctx_make. +func GeoClipCtxMake(gs *Geom) unsafe.Pointer { + _cret := C.geo_clip_ctx_make(gs._inner) + return unsafe.Pointer(_cret) +} + + +// GeoClipCtxFree wraps MEOS C function geo_clip_ctx_free. +func GeoClipCtxFree(ctx unsafe.Pointer) { + C.geo_clip_ctx_free(unsafe.Pointer(ctx)) +} + + +// GeoIntersects2d wraps MEOS C function geo_intersects2d. +func GeoIntersects2d(gs1 *Geom, gs2 *Geom) bool { + _cret := C.geo_intersects2d(gs1._inner, gs2._inner) + return bool(_cret) +} + + +// GeoIntersects2dCtx wraps MEOS C function geo_intersects2d_ctx. +func GeoIntersects2dCtx(gs *Geom, ctx unsafe.Pointer) bool { + _cret := C.geo_intersects2d_ctx(gs._inner, unsafe.Pointer(ctx)) + return bool(_cret) +} + + +// GeoCovers2d wraps MEOS C function geo_covers2d. +func GeoCovers2d(gs1 *Geom, gs2 *Geom) bool { + _cret := C.geo_covers2d(gs1._inner, gs2._inner) + return bool(_cret) +} + + // TpointLinearInterGeom wraps MEOS C function tpoint_linear_inter_geom. func TpointLinearInterGeom(temp *Temporal, gs *Geom, clip bool) *Temporal { _cret := C.tpoint_linear_inter_geom(temp._inner, gs._inner, C.bool(clip)) @@ -396,6 +439,13 @@ func TpointLinearInterGeom(temp *Temporal, gs *Geom, clip bool) *Temporal { } +// TpointLinearInterGeomCtx wraps MEOS C function tpoint_linear_inter_geom_ctx. +func TpointLinearInterGeomCtx(temp *Temporal, ctx unsafe.Pointer, clip bool) *Temporal { + _cret := C.tpoint_linear_inter_geom_ctx(temp._inner, unsafe.Pointer(ctx), C.bool(clip)) + return &Temporal{_inner: _cret} +} + + // TpointLinearDwithinGeom wraps MEOS C function tpoint_linear_dwithin_geom. func TpointLinearDwithinGeom(temp *Temporal, gs *Geom, dist float64) *Temporal { _cret := C.tpoint_linear_dwithin_geom(temp._inner, gs._inner, C.double(dist)) @@ -403,6 +453,13 @@ func TpointLinearDwithinGeom(temp *Temporal, gs *Geom, dist float64) *Temporal { } +// TpointLinearDwithinGeomCtx wraps MEOS C function tpoint_linear_dwithin_geom_ctx. +func TpointLinearDwithinGeomCtx(temp *Temporal, ctx unsafe.Pointer, dist float64) *Temporal { + _cret := C.tpoint_linear_dwithin_geom_ctx(temp._inner, unsafe.Pointer(ctx), C.double(dist)) + return &Temporal{_inner: _cret} +} + + // TpointLinearDistanceGeom wraps MEOS C function tpoint_linear_distance_geom. func TpointLinearDistanceGeom(temp *Temporal, gs *Geom) *Temporal { _cret := C.tpoint_linear_distance_geom(temp._inner, gs._inner) @@ -522,13 +579,6 @@ func TgeoseqsetSplitNStboxes(ss *TSequenceSet, max_count int, count unsafe.Point } -// TpointGetCoord wraps MEOS C function tpoint_get_coord. -func TpointGetCoord(temp *Temporal, coord int) *Temporal { - _cret := C.tpoint_get_coord(temp._inner, C.int(coord)) - return &Temporal{_inner: _cret} -} - - // TgeominstTgeoginst wraps MEOS C function tgeominst_tgeoginst. func TgeominstTgeoginst(inst *TInstant, oper bool) *TInstant { _cret := C.tgeominst_tgeoginst(inst._inner, C.bool(oper)) diff --git a/functions/meos_meos_json.go b/functions/meos_meos_json.go index c21e0d1..16250d5 100644 --- a/functions/meos_meos_json.go +++ b/functions/meos_meos_json.go @@ -773,18 +773,18 @@ func JsonbsetDeleteArray(set *Set, keys unsafe.Pointer, count int) *Set { // JsonbsetExists wraps MEOS C function jsonbset_exists. -func JsonbsetExists(set *Set, key string) *Set { +func JsonbsetExists(set *Set, key string, count unsafe.Pointer) unsafe.Pointer { _c_key := C.cstring_to_text(C.CString(key)) defer C.free(unsafe.Pointer(_c_key)) - _cret := C.jsonbset_exists(set._inner, _c_key) - return &Set{_inner: _cret} + _cret := C.jsonbset_exists(set._inner, _c_key, (*C.int)(unsafe.Pointer(count))) + return unsafe.Pointer(_cret) } // JsonbsetExistsArray wraps MEOS C function jsonbset_exists_array. -func JsonbsetExistsArray(set *Set, keys unsafe.Pointer, count int, any bool) *Set { - _cret := C.jsonbset_exists_array(set._inner, (**C.text)(unsafe.Pointer(keys)), C.int(count), C.bool(any)) - return &Set{_inner: _cret} +func JsonbsetExistsArray(set *Set, keys unsafe.Pointer, count int, any bool, rescount unsafe.Pointer) unsafe.Pointer { + _cret := C.jsonbset_exists_array(set._inner, (**C.text)(unsafe.Pointer(keys)), C.int(count), C.bool(any), (*C.int)(unsafe.Pointer(rescount))) + return unsafe.Pointer(_cret) } @@ -815,6 +815,15 @@ func JsonbsetToIntset(set *Set, key string, null_handle NullHandleType) *Set { } +// JsonbsetToBigintset wraps MEOS C function jsonbset_to_bigintset. +func JsonbsetToBigintset(set *Set, key string, null_handle NullHandleType) *Set { + _c_key := C.CString(key) + defer C.free(unsafe.Pointer(_c_key)) + _cret := C.jsonbset_to_bigintset(set._inner, _c_key, C.nullHandleType(null_handle)) + return &Set{_inner: _cret} +} + + // JsonbsetToFloatset wraps MEOS C function jsonbset_to_floatset. func JsonbsetToFloatset(set *Set, key string, null_handle NullHandleType) *Set { _c_key := C.CString(key) @@ -869,16 +878,16 @@ func JsonbsetInsert(set *Set, path_elems unsafe.Pointer, path_len int, newjb *Js // JsonbsetPathExists wraps MEOS C function jsonbset_path_exists. -func JsonbsetPathExists(set *Set, jp *JsonPath, vars *Jsonb, silent bool, tz bool) *Set { - _cret := C.jsonbset_path_exists(set._inner, jp._inner, vars._inner, C.bool(silent), C.bool(tz)) - return &Set{_inner: _cret} +func JsonbsetPathExists(set *Set, jp *JsonPath, vars *Jsonb, silent bool, tz bool, count unsafe.Pointer) unsafe.Pointer { + _cret := C.jsonbset_path_exists(set._inner, jp._inner, vars._inner, C.bool(silent), C.bool(tz), (*C.int)(unsafe.Pointer(count))) + return unsafe.Pointer(_cret) } // JsonbsetPathMatch wraps MEOS C function jsonbset_path_match. -func JsonbsetPathMatch(set *Set, jp *JsonPath, vars *Jsonb, silent bool, tz bool) *Set { - _cret := C.jsonbset_path_match(set._inner, jp._inner, vars._inner, C.bool(silent), C.bool(tz)) - return &Set{_inner: _cret} +func JsonbsetPathMatch(set *Set, jp *JsonPath, vars *Jsonb, silent bool, tz bool, count unsafe.Pointer) unsafe.Pointer { + _cret := C.jsonbset_path_match(set._inner, jp._inner, vars._inner, C.bool(silent), C.bool(tz), (*C.int)(unsafe.Pointer(count))) + return unsafe.Pointer(_cret) } @@ -1224,6 +1233,20 @@ func TjsonbExists(temp *Temporal, key string) *Temporal { } +// TjsonbExistsAll wraps MEOS C function tjsonb_exists_all. +func TjsonbExistsAll(temp *Temporal, keys unsafe.Pointer, count int) *Temporal { + _cret := C.tjsonb_exists_all(temp._inner, (**C.text)(unsafe.Pointer(keys)), C.int(count)) + return &Temporal{_inner: _cret} +} + + +// TjsonbExistsAny wraps MEOS C function tjsonb_exists_any. +func TjsonbExistsAny(temp *Temporal, keys unsafe.Pointer, count int) *Temporal { + _cret := C.tjsonb_exists_any(temp._inner, (**C.text)(unsafe.Pointer(keys)), C.int(count)) + return &Temporal{_inner: _cret} +} + + // TjsonbExistsArray wraps MEOS C function tjsonb_exists_array. func TjsonbExistsArray(temp *Temporal, keys unsafe.Pointer, count int, any bool) *Temporal { _cret := C.tjsonb_exists_array(temp._inner, (**C.text)(unsafe.Pointer(keys)), C.int(count), C.bool(any)) diff --git a/functions/meos_meos_pointcloud.go b/functions/meos_meos_pointcloud.go index 91e4a66..fdcabe6 100644 --- a/functions/meos_meos_pointcloud.go +++ b/functions/meos_meos_pointcloud.go @@ -791,12 +791,6 @@ func TpcboxToSTBOX(box *TPCBox) *STBox { } -// TpcboxExpand wraps MEOS C function tpcbox_expand. -func TpcboxExpand(box1 *TPCBox, box2 *TPCBox) { - C.tpcbox_expand(box1._inner, box2._inner) -} - - // TpcboxRound wraps MEOS C function tpcbox_round. func TpcboxRound(box *TPCBox, maxdd int) *TPCBox { _cret := C.tpcbox_round(box._inner, C.int(maxdd)) @@ -1036,13 +1030,409 @@ func EnsureSamePcidTpcbox(box1 *TPCBox, box2 *TPCBox) bool { } -// TpointcloudinstMake wraps MEOS C function tpointcloudinst_make. -func TpointcloudinstMake(pt *Pcpoint, t int64) *TInstant { - _cret := C.tpointcloudinst_make(pt._inner, C.TimestampTz(t)) +// TpointcloudToTgeompoint wraps MEOS C function tpointcloud_to_tgeompoint. +func TpointcloudToTgeompoint(temp *Temporal) *Temporal { + _cret := C.tpointcloud_to_tgeompoint(temp._inner) + return &Temporal{_inner: _cret} +} + + +// TpcpointinstMake wraps MEOS C function tpcpointinst_make. +func TpcpointinstMake(pt *Pcpoint, t int64) *TInstant { + _cret := C.tpcpointinst_make(pt._inner, C.TimestampTz(t)) + return &TInstant{_inner: _cret} +} + + +// TpcpointseqFromBaseTstzset wraps MEOS C function tpcpointseq_from_base_tstzset. +func TpcpointseqFromBaseTstzset(pt *Pcpoint, s *Set) *TSequence { + _cret := C.tpcpointseq_from_base_tstzset(pt._inner, s._inner) + return &TSequence{_inner: _cret} +} + + +// TpcpointseqFromBaseTstzspan wraps MEOS C function tpcpointseq_from_base_tstzspan. +func TpcpointseqFromBaseTstzspan(pt *Pcpoint, sp *Span) *TSequence { + _cret := C.tpcpointseq_from_base_tstzspan(pt._inner, sp._inner) + return &TSequence{_inner: _cret} +} + + +// TpcpointseqsetFromBaseTstzspanset wraps MEOS C function tpcpointseqset_from_base_tstzspanset. +func TpcpointseqsetFromBaseTstzspanset(pt *Pcpoint, ss *SpanSet) *TSequenceSet { + _cret := C.tpcpointseqset_from_base_tstzspanset(pt._inner, ss._inner) + return &TSequenceSet{_inner: _cret} +} + + +// TpcpointFromBaseTemp wraps MEOS C function tpcpoint_from_base_temp. +func TpcpointFromBaseTemp(pt *Pcpoint, temp *Temporal) *Temporal { + _cret := C.tpcpoint_from_base_temp(pt._inner, temp._inner) + return &Temporal{_inner: _cret} +} + + +// TpcpointStartValue wraps MEOS C function tpcpoint_start_value. +func TpcpointStartValue(temp *Temporal) *Pcpoint { + _cret := C.tpcpoint_start_value(temp._inner) + return &Pcpoint{_inner: _cret} +} + + +// TpcpointEndValue wraps MEOS C function tpcpoint_end_value. +func TpcpointEndValue(temp *Temporal) *Pcpoint { + _cret := C.tpcpoint_end_value(temp._inner) + return &Pcpoint{_inner: _cret} +} + + +// TpcpointValueN wraps MEOS C function tpcpoint_value_n. +func TpcpointValueN(temp *Temporal, n int) (bool, *Pcpoint) { + var _out_result *C.Pcpoint + _cret := C.tpcpoint_value_n(temp._inner, C.int(n), &_out_result) + return bool(_cret), &Pcpoint{_inner: _out_result} +} + + +// TpcpointValues wraps MEOS C function tpcpoint_values. +func TpcpointValues(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { + _cret := C.tpcpoint_values(temp._inner, (*C.int)(unsafe.Pointer(count))) + return unsafe.Pointer(_cret) +} + + +// TpcpointValueAtTimestamptz wraps MEOS C function tpcpoint_value_at_timestamptz. +func TpcpointValueAtTimestamptz(temp *Temporal, t int64, strict bool) (bool, *Pcpoint) { + var _out_value *C.Pcpoint + _cret := C.tpcpoint_value_at_timestamptz(temp._inner, C.TimestampTz(t), C.bool(strict), &_out_value) + return bool(_cret), &Pcpoint{_inner: _out_value} +} + + +// TpcpointAtValue wraps MEOS C function tpcpoint_at_value. +func TpcpointAtValue(temp *Temporal, pt *Pcpoint) *Temporal { + _cret := C.tpcpoint_at_value(temp._inner, pt._inner) + return &Temporal{_inner: _cret} +} + + +// TpcpointMinusValue wraps MEOS C function tpcpoint_minus_value. +func TpcpointMinusValue(temp *Temporal, pt *Pcpoint) *Temporal { + _cret := C.tpcpoint_minus_value(temp._inner, pt._inner) + return &Temporal{_inner: _cret} +} + + +// TpcpatchinstMake wraps MEOS C function tpcpatchinst_make. +func TpcpatchinstMake(pa *Pcpatch, t int64) *TInstant { + _cret := C.tpcpatchinst_make(pa._inner, C.TimestampTz(t)) return &TInstant{_inner: _cret} } +// TpcpatchseqFromBaseTstzset wraps MEOS C function tpcpatchseq_from_base_tstzset. +func TpcpatchseqFromBaseTstzset(pa *Pcpatch, s *Set) *TSequence { + _cret := C.tpcpatchseq_from_base_tstzset(pa._inner, s._inner) + return &TSequence{_inner: _cret} +} + + +// TpcpatchseqFromBaseTstzspan wraps MEOS C function tpcpatchseq_from_base_tstzspan. +func TpcpatchseqFromBaseTstzspan(pa *Pcpatch, sp *Span) *TSequence { + _cret := C.tpcpatchseq_from_base_tstzspan(pa._inner, sp._inner) + return &TSequence{_inner: _cret} +} + + +// TpcpatchseqsetFromBaseTstzspanset wraps MEOS C function tpcpatchseqset_from_base_tstzspanset. +func TpcpatchseqsetFromBaseTstzspanset(pa *Pcpatch, ss *SpanSet) *TSequenceSet { + _cret := C.tpcpatchseqset_from_base_tstzspanset(pa._inner, ss._inner) + return &TSequenceSet{_inner: _cret} +} + + +// TpcpatchFromBaseTemp wraps MEOS C function tpcpatch_from_base_temp. +func TpcpatchFromBaseTemp(pa *Pcpatch, temp *Temporal) *Temporal { + _cret := C.tpcpatch_from_base_temp(pa._inner, temp._inner) + return &Temporal{_inner: _cret} +} + + +// TpcpatchStartValue wraps MEOS C function tpcpatch_start_value. +func TpcpatchStartValue(temp *Temporal) *Pcpatch { + _cret := C.tpcpatch_start_value(temp._inner) + return &Pcpatch{_inner: _cret} +} + + +// TpcpatchEndValue wraps MEOS C function tpcpatch_end_value. +func TpcpatchEndValue(temp *Temporal) *Pcpatch { + _cret := C.tpcpatch_end_value(temp._inner) + return &Pcpatch{_inner: _cret} +} + + +// TpcpatchValueN wraps MEOS C function tpcpatch_value_n. +func TpcpatchValueN(temp *Temporal, n int) (bool, *Pcpatch) { + var _out_result *C.Pcpatch + _cret := C.tpcpatch_value_n(temp._inner, C.int(n), &_out_result) + return bool(_cret), &Pcpatch{_inner: _out_result} +} + + +// TpcpatchValues wraps MEOS C function tpcpatch_values. +func TpcpatchValues(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { + _cret := C.tpcpatch_values(temp._inner, (*C.int)(unsafe.Pointer(count))) + return unsafe.Pointer(_cret) +} + + +// TpcpatchValueAtTimestamptz wraps MEOS C function tpcpatch_value_at_timestamptz. +func TpcpatchValueAtTimestamptz(temp *Temporal, t int64, strict bool) (bool, *Pcpatch) { + var _out_value *C.Pcpatch + _cret := C.tpcpatch_value_at_timestamptz(temp._inner, C.TimestampTz(t), C.bool(strict), &_out_value) + return bool(_cret), &Pcpatch{_inner: _out_value} +} + + +// TpcpatchAtValue wraps MEOS C function tpcpatch_at_value. +func TpcpatchAtValue(temp *Temporal, pa *Pcpatch) *Temporal { + _cret := C.tpcpatch_at_value(temp._inner, pa._inner) + return &Temporal{_inner: _cret} +} + + +// TpcpatchMinusValue wraps MEOS C function tpcpatch_minus_value. +func TpcpatchMinusValue(temp *Temporal, pa *Pcpatch) *Temporal { + _cret := C.tpcpatch_minus_value(temp._inner, pa._inner) + return &Temporal{_inner: _cret} +} + + +// EverEqPcpointTpcpoint wraps MEOS C function ever_eq_pcpoint_tpcpoint. +func EverEqPcpointTpcpoint(pt *Pcpoint, temp *Temporal) int { + _cret := C.ever_eq_pcpoint_tpcpoint(pt._inner, temp._inner) + return int(_cret) +} + + +// EverEqTpcpointPcpoint wraps MEOS C function ever_eq_tpcpoint_pcpoint. +func EverEqTpcpointPcpoint(temp *Temporal, pt *Pcpoint) int { + _cret := C.ever_eq_tpcpoint_pcpoint(temp._inner, pt._inner) + return int(_cret) +} + + +// EverEqTpcpointTpcpoint wraps MEOS C function ever_eq_tpcpoint_tpcpoint. +func EverEqTpcpointTpcpoint(temp1 *Temporal, temp2 *Temporal) int { + _cret := C.ever_eq_tpcpoint_tpcpoint(temp1._inner, temp2._inner) + return int(_cret) +} + + +// EverNePcpointTpcpoint wraps MEOS C function ever_ne_pcpoint_tpcpoint. +func EverNePcpointTpcpoint(pt *Pcpoint, temp *Temporal) int { + _cret := C.ever_ne_pcpoint_tpcpoint(pt._inner, temp._inner) + return int(_cret) +} + + +// EverNeTpcpointPcpoint wraps MEOS C function ever_ne_tpcpoint_pcpoint. +func EverNeTpcpointPcpoint(temp *Temporal, pt *Pcpoint) int { + _cret := C.ever_ne_tpcpoint_pcpoint(temp._inner, pt._inner) + return int(_cret) +} + + +// EverNeTpcpointTpcpoint wraps MEOS C function ever_ne_tpcpoint_tpcpoint. +func EverNeTpcpointTpcpoint(temp1 *Temporal, temp2 *Temporal) int { + _cret := C.ever_ne_tpcpoint_tpcpoint(temp1._inner, temp2._inner) + return int(_cret) +} + + +// AlwaysEqPcpointTpcpoint wraps MEOS C function always_eq_pcpoint_tpcpoint. +func AlwaysEqPcpointTpcpoint(pt *Pcpoint, temp *Temporal) int { + _cret := C.always_eq_pcpoint_tpcpoint(pt._inner, temp._inner) + return int(_cret) +} + + +// AlwaysEqTpcpointPcpoint wraps MEOS C function always_eq_tpcpoint_pcpoint. +func AlwaysEqTpcpointPcpoint(temp *Temporal, pt *Pcpoint) int { + _cret := C.always_eq_tpcpoint_pcpoint(temp._inner, pt._inner) + return int(_cret) +} + + +// AlwaysEqTpcpointTpcpoint wraps MEOS C function always_eq_tpcpoint_tpcpoint. +func AlwaysEqTpcpointTpcpoint(temp1 *Temporal, temp2 *Temporal) int { + _cret := C.always_eq_tpcpoint_tpcpoint(temp1._inner, temp2._inner) + return int(_cret) +} + + +// AlwaysNePcpointTpcpoint wraps MEOS C function always_ne_pcpoint_tpcpoint. +func AlwaysNePcpointTpcpoint(pt *Pcpoint, temp *Temporal) int { + _cret := C.always_ne_pcpoint_tpcpoint(pt._inner, temp._inner) + return int(_cret) +} + + +// AlwaysNeTpcpointPcpoint wraps MEOS C function always_ne_tpcpoint_pcpoint. +func AlwaysNeTpcpointPcpoint(temp *Temporal, pt *Pcpoint) int { + _cret := C.always_ne_tpcpoint_pcpoint(temp._inner, pt._inner) + return int(_cret) +} + + +// AlwaysNeTpcpointTpcpoint wraps MEOS C function always_ne_tpcpoint_tpcpoint. +func AlwaysNeTpcpointTpcpoint(temp1 *Temporal, temp2 *Temporal) int { + _cret := C.always_ne_tpcpoint_tpcpoint(temp1._inner, temp2._inner) + return int(_cret) +} + + +// EverEqPcpatchTpcpatch wraps MEOS C function ever_eq_pcpatch_tpcpatch. +func EverEqPcpatchTpcpatch(pa *Pcpatch, temp *Temporal) int { + _cret := C.ever_eq_pcpatch_tpcpatch(pa._inner, temp._inner) + return int(_cret) +} + + +// EverEqTpcpatchPcpatch wraps MEOS C function ever_eq_tpcpatch_pcpatch. +func EverEqTpcpatchPcpatch(temp *Temporal, pa *Pcpatch) int { + _cret := C.ever_eq_tpcpatch_pcpatch(temp._inner, pa._inner) + return int(_cret) +} + + +// EverEqTpcpatchTpcpatch wraps MEOS C function ever_eq_tpcpatch_tpcpatch. +func EverEqTpcpatchTpcpatch(temp1 *Temporal, temp2 *Temporal) int { + _cret := C.ever_eq_tpcpatch_tpcpatch(temp1._inner, temp2._inner) + return int(_cret) +} + + +// EverNePcpatchTpcpatch wraps MEOS C function ever_ne_pcpatch_tpcpatch. +func EverNePcpatchTpcpatch(pa *Pcpatch, temp *Temporal) int { + _cret := C.ever_ne_pcpatch_tpcpatch(pa._inner, temp._inner) + return int(_cret) +} + + +// EverNeTpcpatchPcpatch wraps MEOS C function ever_ne_tpcpatch_pcpatch. +func EverNeTpcpatchPcpatch(temp *Temporal, pa *Pcpatch) int { + _cret := C.ever_ne_tpcpatch_pcpatch(temp._inner, pa._inner) + return int(_cret) +} + + +// EverNeTpcpatchTpcpatch wraps MEOS C function ever_ne_tpcpatch_tpcpatch. +func EverNeTpcpatchTpcpatch(temp1 *Temporal, temp2 *Temporal) int { + _cret := C.ever_ne_tpcpatch_tpcpatch(temp1._inner, temp2._inner) + return int(_cret) +} + + +// AlwaysEqPcpatchTpcpatch wraps MEOS C function always_eq_pcpatch_tpcpatch. +func AlwaysEqPcpatchTpcpatch(pa *Pcpatch, temp *Temporal) int { + _cret := C.always_eq_pcpatch_tpcpatch(pa._inner, temp._inner) + return int(_cret) +} + + +// AlwaysEqTpcpatchPcpatch wraps MEOS C function always_eq_tpcpatch_pcpatch. +func AlwaysEqTpcpatchPcpatch(temp *Temporal, pa *Pcpatch) int { + _cret := C.always_eq_tpcpatch_pcpatch(temp._inner, pa._inner) + return int(_cret) +} + + +// AlwaysEqTpcpatchTpcpatch wraps MEOS C function always_eq_tpcpatch_tpcpatch. +func AlwaysEqTpcpatchTpcpatch(temp1 *Temporal, temp2 *Temporal) int { + _cret := C.always_eq_tpcpatch_tpcpatch(temp1._inner, temp2._inner) + return int(_cret) +} + + +// AlwaysNePcpatchTpcpatch wraps MEOS C function always_ne_pcpatch_tpcpatch. +func AlwaysNePcpatchTpcpatch(pa *Pcpatch, temp *Temporal) int { + _cret := C.always_ne_pcpatch_tpcpatch(pa._inner, temp._inner) + return int(_cret) +} + + +// AlwaysNeTpcpatchPcpatch wraps MEOS C function always_ne_tpcpatch_pcpatch. +func AlwaysNeTpcpatchPcpatch(temp *Temporal, pa *Pcpatch) int { + _cret := C.always_ne_tpcpatch_pcpatch(temp._inner, pa._inner) + return int(_cret) +} + + +// AlwaysNeTpcpatchTpcpatch wraps MEOS C function always_ne_tpcpatch_tpcpatch. +func AlwaysNeTpcpatchTpcpatch(temp1 *Temporal, temp2 *Temporal) int { + _cret := C.always_ne_tpcpatch_tpcpatch(temp1._inner, temp2._inner) + return int(_cret) +} + + +// TeqPcpointTpcpoint wraps MEOS C function teq_pcpoint_tpcpoint. +func TeqPcpointTpcpoint(pt *Pcpoint, temp *Temporal) *Temporal { + _cret := C.teq_pcpoint_tpcpoint(pt._inner, temp._inner) + return &Temporal{_inner: _cret} +} + + +// TeqTpcpointPcpoint wraps MEOS C function teq_tpcpoint_pcpoint. +func TeqTpcpointPcpoint(temp *Temporal, pt *Pcpoint) *Temporal { + _cret := C.teq_tpcpoint_pcpoint(temp._inner, pt._inner) + return &Temporal{_inner: _cret} +} + + +// TnePcpointTpcpoint wraps MEOS C function tne_pcpoint_tpcpoint. +func TnePcpointTpcpoint(pt *Pcpoint, temp *Temporal) *Temporal { + _cret := C.tne_pcpoint_tpcpoint(pt._inner, temp._inner) + return &Temporal{_inner: _cret} +} + + +// TneTpcpointPcpoint wraps MEOS C function tne_tpcpoint_pcpoint. +func TneTpcpointPcpoint(temp *Temporal, pt *Pcpoint) *Temporal { + _cret := C.tne_tpcpoint_pcpoint(temp._inner, pt._inner) + return &Temporal{_inner: _cret} +} + + +// TeqPcpatchTpcpatch wraps MEOS C function teq_pcpatch_tpcpatch. +func TeqPcpatchTpcpatch(pa *Pcpatch, temp *Temporal) *Temporal { + _cret := C.teq_pcpatch_tpcpatch(pa._inner, temp._inner) + return &Temporal{_inner: _cret} +} + + +// TeqTpcpatchPcpatch wraps MEOS C function teq_tpcpatch_pcpatch. +func TeqTpcpatchPcpatch(temp *Temporal, pa *Pcpatch) *Temporal { + _cret := C.teq_tpcpatch_pcpatch(temp._inner, pa._inner) + return &Temporal{_inner: _cret} +} + + +// TnePcpatchTpcpatch wraps MEOS C function tne_pcpatch_tpcpatch. +func TnePcpatchTpcpatch(pa *Pcpatch, temp *Temporal) *Temporal { + _cret := C.tne_pcpatch_tpcpatch(pa._inner, temp._inner) + return &Temporal{_inner: _cret} +} + + +// TneTpcpatchPcpatch wraps MEOS C function tne_tpcpatch_pcpatch. +func TneTpcpatchPcpatch(temp *Temporal, pa *Pcpatch) *Temporal { + _cret := C.tne_tpcpatch_pcpatch(temp._inner, pa._inner) + return &Temporal{_inner: _cret} +} + + // EintersectsTpcpointGeo wraps MEOS C function eintersects_tpcpoint_geo. func EintersectsTpcpointGeo(temp *Temporal, gs *Geom) bool { _cret := C.eintersects_tpcpoint_geo(temp._inner, gs._inner) diff --git a/functions/meos_meos_pose.go b/functions/meos_meos_pose.go index 47da5bb..6464024 100644 --- a/functions/meos_meos_pose.go +++ b/functions/meos_meos_pose.go @@ -177,6 +177,20 @@ func TposeAsGeopose(temp *Temporal, conformance int, precision int) string { } +// TposeAsGeoposeStreamHeader wraps MEOS C function tpose_as_geopose_stream_header. +func TposeAsGeoposeStreamHeader(temp *Temporal, precision int) string { + _cret := C.tpose_as_geopose_stream_header(temp._inner, C.int(precision)) + return C.GoString(_cret) +} + + +// TposeAsGeoposeStreamElement wraps MEOS C function tpose_as_geopose_stream_element. +func TposeAsGeoposeStreamElement(temp *Temporal, inst *TInstant, precision int) string { + _cret := C.tpose_as_geopose_stream_element(temp._inner, inst._inner, C.int(precision)) + return C.GoString(_cret) +} + + // PoseApplyGeo wraps MEOS C function pose_apply_geo. func PoseApplyGeo(pose *Pose, body *Geom) *Geom { _cret := C.pose_apply_geo(pose._inner, body._inner) @@ -318,8 +332,9 @@ func PosearrRound(posearr unsafe.Pointer, count int, maxdd int) unsafe.Pointer { // PoseSetSRID wraps MEOS C function pose_set_srid. -func PoseSetSRID(pose *Pose, srid int32) { - C.pose_set_srid(pose._inner, C.int32_t(srid)) +func PoseSetSRID(pose *Pose, srid int32) *Pose { + _cret := C.pose_set_srid(pose._inner, C.int32_t(srid)) + return &Pose{_inner: _cret} } diff --git a/functions/meos_meos_quadbin.go b/functions/meos_meos_quadbin.go index 50b349f..a6ebef3 100644 --- a/functions/meos_meos_quadbin.go +++ b/functions/meos_meos_quadbin.go @@ -85,6 +85,78 @@ import ( var _ = unsafe.Pointer(nil) +// QuadbinIn wraps MEOS C function quadbin_in. +func QuadbinIn(str string) uint64 { + _c_str := C.CString(str) + defer C.free(unsafe.Pointer(_c_str)) + _cret := C.quadbin_in(_c_str) + return uint64(_cret) +} + + +// QuadbinEq wraps MEOS C function quadbin_eq. +func QuadbinEq(a uint64, b uint64) bool { + _cret := C.quadbin_eq(C.uint64_t(a), C.uint64_t(b)) + return bool(_cret) +} + + +// QuadbinNe wraps MEOS C function quadbin_ne. +func QuadbinNe(a uint64, b uint64) bool { + _cret := C.quadbin_ne(C.uint64_t(a), C.uint64_t(b)) + return bool(_cret) +} + + +// QuadbinLt wraps MEOS C function quadbin_lt. +func QuadbinLt(a uint64, b uint64) bool { + _cret := C.quadbin_lt(C.uint64_t(a), C.uint64_t(b)) + return bool(_cret) +} + + +// QuadbinLe wraps MEOS C function quadbin_le. +func QuadbinLe(a uint64, b uint64) bool { + _cret := C.quadbin_le(C.uint64_t(a), C.uint64_t(b)) + return bool(_cret) +} + + +// QuadbinGt wraps MEOS C function quadbin_gt. +func QuadbinGt(a uint64, b uint64) bool { + _cret := C.quadbin_gt(C.uint64_t(a), C.uint64_t(b)) + return bool(_cret) +} + + +// QuadbinGe wraps MEOS C function quadbin_ge. +func QuadbinGe(a uint64, b uint64) bool { + _cret := C.quadbin_ge(C.uint64_t(a), C.uint64_t(b)) + return bool(_cret) +} + + +// QuadbinCmp wraps MEOS C function quadbin_cmp. +func QuadbinCmp(a uint64, b uint64) int { + _cret := C.quadbin_cmp(C.uint64_t(a), C.uint64_t(b)) + return int(_cret) +} + + +// QuadbinHash wraps MEOS C function quadbin_hash. +func QuadbinHash(cell uint64) uint32 { + _cret := C.quadbin_hash(C.uint64_t(cell)) + return uint32(_cret) +} + + +// QuadbinHashExtended wraps MEOS C function quadbin_hash_extended. +func QuadbinHashExtended(cell uint64, seed uint64) uint64 { + _cret := C.quadbin_hash_extended(C.uint64_t(cell), C.uint64_t(seed)) + return uint64(_cret) +} + + // QuadbinIsValidIndex wraps MEOS C function quadbin_is_valid_index. func QuadbinIsValidIndex(index uint64) bool { _cret := C.quadbin_is_valid_index(C.uint64_t(index)) @@ -107,8 +179,9 @@ func QuadbinTileToCell(x uint32, y uint32, z uint32) uint64 { // QuadbinCellToTile wraps MEOS C function quadbin_cell_to_tile. -func QuadbinCellToTile(cell uint64, x unsafe.Pointer, y unsafe.Pointer, z unsafe.Pointer) { - C.quadbin_cell_to_tile(C.uint64_t(cell), (*C.uint32_t)(unsafe.Pointer(x)), (*C.uint32_t)(unsafe.Pointer(y)), (*C.uint32_t)(unsafe.Pointer(z))) +func QuadbinCellToTile(cell uint64, x unsafe.Pointer, y unsafe.Pointer, z unsafe.Pointer) bool { + _cret := C.quadbin_cell_to_tile(C.uint64_t(cell), (*C.uint32_t)(unsafe.Pointer(x)), (*C.uint32_t)(unsafe.Pointer(y)), (*C.uint32_t)(unsafe.Pointer(z))) + return bool(_cret) } @@ -156,15 +229,45 @@ func QuadbinPointToCell(longitude float64, latitude float64, resolution uint32) } -// QuadbinCellToPoint wraps MEOS C function quadbin_cell_to_point. -func QuadbinCellToPoint(cell uint64, longitude unsafe.Pointer, latitude unsafe.Pointer) { - C.quadbin_cell_to_point(C.uint64_t(cell), (*C.double)(unsafe.Pointer(longitude)), (*C.double)(unsafe.Pointer(latitude))) +// GeoToQuadbinCell wraps MEOS C function geo_to_quadbin_cell. +func GeoToQuadbinCell(point *Geom, resolution int32) uint64 { + _cret := C.geo_to_quadbin_cell(point._inner, C.int32(resolution)) + return uint64(_cret) +} + + +// QuadbinCellToGeompoint wraps MEOS C function quadbin_cell_to_geompoint. +func QuadbinCellToGeompoint(cell uint64) *Geom { + _cret := C.quadbin_cell_to_geompoint(C.uint64_t(cell)) + return &Geom{_inner: _cret} } -// QuadbinCellToBoundingBox wraps MEOS C function quadbin_cell_to_bounding_box. -func QuadbinCellToBoundingBox(cell uint64, xmin unsafe.Pointer, ymin unsafe.Pointer, xmax unsafe.Pointer, ymax unsafe.Pointer) { - C.quadbin_cell_to_bounding_box(C.uint64_t(cell), (*C.double)(unsafe.Pointer(xmin)), (*C.double)(unsafe.Pointer(ymin)), (*C.double)(unsafe.Pointer(xmax)), (*C.double)(unsafe.Pointer(ymax))) +// QuadbinCellToGeom wraps MEOS C function quadbin_cell_to_geom. +func QuadbinCellToGeom(cell uint64) *Geom { + _cret := C.quadbin_cell_to_geom(C.uint64_t(cell)) + return &Geom{_inner: _cret} +} + + +// QuadbinToSTBOX wraps MEOS C function quadbin_to_stbox. +func QuadbinToSTBOX(cell uint64) *STBox { + _cret := C.quadbin_to_stbox(C.uint64_t(cell)) + return &STBox{_inner: _cret} +} + + +// QuadbinTimestamptzToSTBOX wraps MEOS C function quadbin_timestamptz_to_stbox. +func QuadbinTimestamptzToSTBOX(cell uint64, t int64) *STBox { + _cret := C.quadbin_timestamptz_to_stbox(C.uint64_t(cell), C.TimestampTz(t)) + return &STBox{_inner: _cret} +} + + +// QuadbinTstzspanToSTBOX wraps MEOS C function quadbin_tstzspan_to_stbox. +func QuadbinTstzspanToSTBOX(cell uint64, s *Span) *STBox { + _cret := C.quadbin_tstzspan_to_stbox(C.uint64_t(cell), s._inner) + return &STBox{_inner: _cret} } @@ -198,71 +301,6 @@ func QuadbinCellToQuadkey(cell uint64) string { } -// QuadbinParse wraps MEOS C function quadbin_parse. -func QuadbinParse(str string) uint64 { - _c_str := C.CString(str) - defer C.free(unsafe.Pointer(_c_str)) - _cret := C.quadbin_parse(_c_str) - return uint64(_cret) -} - - -// QuadbinEq wraps MEOS C function quadbin_eq. -func QuadbinEq(a uint64, b uint64) bool { - _cret := C.quadbin_eq(C.uint64_t(a), C.uint64_t(b)) - return bool(_cret) -} - - -// QuadbinNe wraps MEOS C function quadbin_ne. -func QuadbinNe(a uint64, b uint64) bool { - _cret := C.quadbin_ne(C.uint64_t(a), C.uint64_t(b)) - return bool(_cret) -} - - -// QuadbinLt wraps MEOS C function quadbin_lt. -func QuadbinLt(a uint64, b uint64) bool { - _cret := C.quadbin_lt(C.uint64_t(a), C.uint64_t(b)) - return bool(_cret) -} - - -// QuadbinLe wraps MEOS C function quadbin_le. -func QuadbinLe(a uint64, b uint64) bool { - _cret := C.quadbin_le(C.uint64_t(a), C.uint64_t(b)) - return bool(_cret) -} - - -// QuadbinGt wraps MEOS C function quadbin_gt. -func QuadbinGt(a uint64, b uint64) bool { - _cret := C.quadbin_gt(C.uint64_t(a), C.uint64_t(b)) - return bool(_cret) -} - - -// QuadbinGe wraps MEOS C function quadbin_ge. -func QuadbinGe(a uint64, b uint64) bool { - _cret := C.quadbin_ge(C.uint64_t(a), C.uint64_t(b)) - return bool(_cret) -} - - -// QuadbinCmp wraps MEOS C function quadbin_cmp. -func QuadbinCmp(a uint64, b uint64) int { - _cret := C.quadbin_cmp(C.uint64_t(a), C.uint64_t(b)) - return int(_cret) -} - - -// QuadbinHash wraps MEOS C function quadbin_hash. -func QuadbinHash(cell uint64) uint32 { - _cret := C.quadbin_hash(C.uint64_t(cell)) - return uint32(_cret) -} - - // QuadbinGridDisk wraps MEOS C function quadbin_grid_disk. func QuadbinGridDisk(origin uint64, k int) *Set { _cret := C.quadbin_grid_disk(C.uint64_t(origin), C.int(k)) diff --git a/functions/meos_meos_rgeo.go b/functions/meos_meos_rgeo.go index fb292a9..7626c0b 100644 --- a/functions/meos_meos_rgeo.go +++ b/functions/meos_meos_rgeo.go @@ -85,6 +85,24 @@ import ( var _ = unsafe.Pointer(nil) +// TrgeometryIn wraps MEOS C function trgeometry_in. +func TrgeometryIn(str string) *Temporal { + _c_str := C.CString(str) + defer C.free(unsafe.Pointer(_c_str)) + _cret := C.trgeometry_in(_c_str) + return &Temporal{_inner: _cret} +} + + +// TrgeometryFromMFJSON wraps MEOS C function trgeometry_from_mfjson. +func TrgeometryFromMFJSON(mfjson string) *Temporal { + _c_mfjson := C.CString(mfjson) + defer C.free(unsafe.Pointer(_c_mfjson)) + _cret := C.trgeometry_from_mfjson(_c_mfjson) + return &Temporal{_inner: _cret} +} + + // TrgeometryOut wraps MEOS C function trgeometry_out. func TrgeometryOut(temp *Temporal) string { _cret := C.trgeometry_out(temp._inner) @@ -92,6 +110,20 @@ func TrgeometryOut(temp *Temporal) string { } +// TrgeometryAsText wraps MEOS C function trgeometry_as_text. +func TrgeometryAsText(temp *Temporal, maxdd int) string { + _cret := C.trgeometry_as_text(temp._inner, C.int(maxdd)) + return C.GoString(_cret) +} + + +// TrgeometryAsEWKT wraps MEOS C function trgeometry_as_ewkt. +func TrgeometryAsEWKT(temp *Temporal, maxdd int) string { + _cret := C.trgeometry_as_ewkt(temp._inner, C.int(maxdd)) + return C.GoString(_cret) +} + + // TrgeometryinstMake wraps MEOS C function trgeometryinst_make. func TrgeometryinstMake(geom *Geom, pose *Pose, t int64) *TInstant { _cret := C.trgeometryinst_make(geom._inner, pose._inner, C.TimestampTz(t)) @@ -99,9 +131,30 @@ func TrgeometryinstMake(geom *Geom, pose *Pose, t int64) *TInstant { } -// GeoTposeToTrgeometry wraps MEOS C function geo_tpose_to_trgeometry. -func GeoTposeToTrgeometry(gs *Geom, temp *Temporal) *Temporal { - _cret := C.geo_tpose_to_trgeometry(gs._inner, temp._inner) +// TrgeometryseqMake wraps MEOS C function trgeometryseq_make. +func TrgeometryseqMake(geom *Geom, instants unsafe.Pointer, count int, lower_inc bool, upper_inc bool, interp Interpolation, normalize bool) *TSequence { + _cret := C.trgeometryseq_make(geom._inner, (**C.TInstant)(unsafe.Pointer(instants)), C.int(count), C.bool(lower_inc), C.bool(upper_inc), C.interpType(interp), C.bool(normalize)) + return &TSequence{_inner: _cret} +} + + +// TrgeometryseqsetMake wraps MEOS C function trgeometryseqset_make. +func TrgeometryseqsetMake(geom *Geom, sequences unsafe.Pointer, count int, normalize bool) *TSequenceSet { + _cret := C.trgeometryseqset_make(geom._inner, (**C.TSequence)(unsafe.Pointer(sequences)), C.int(count), C.bool(normalize)) + return &TSequenceSet{_inner: _cret} +} + + +// TrgeometryseqsetMakeGaps wraps MEOS C function trgeometryseqset_make_gaps. +func TrgeometryseqsetMakeGaps(geom *Geom, instants unsafe.Pointer, count int, interp Interpolation, maxt *Interval, maxdist float64) *TSequenceSet { + _cret := C.trgeometryseqset_make_gaps(geom._inner, (**C.TInstant)(unsafe.Pointer(instants)), C.int(count), C.interpType(interp), maxt._inner, C.double(maxdist)) + return &TSequenceSet{_inner: _cret} +} + + +// GeometryTposeToTrgeometry wraps MEOS C function geometry_tpose_to_trgeometry. +func GeometryTposeToTrgeometry(gs *Geom, temp *Temporal) *Temporal { + _cret := C.geometry_tpose_to_trgeometry(gs._inner, temp._inner) return &Temporal{_inner: _cret} } @@ -113,9 +166,9 @@ func TrgeometryToTpose(temp *Temporal) *Temporal { } -// TrgeometryToTpoint wraps MEOS C function trgeometry_to_tpoint. -func TrgeometryToTpoint(temp *Temporal) *Temporal { - _cret := C.trgeometry_to_tpoint(temp._inner) +// TrgeometryToTgeompoint wraps MEOS C function trgeometry_to_tgeompoint. +func TrgeometryToTgeompoint(temp *Temporal) *Temporal { + _cret := C.trgeometry_to_tgeompoint(temp._inner) return &Temporal{_inner: _cret} } @@ -415,13 +468,31 @@ func TrgeometrySetInterp(temp *Temporal, interp Interpolation) *Temporal { } -// TrgeometryToTinstant wraps MEOS C function trgeometry_to_tinstant. -func TrgeometryToTinstant(temp *Temporal) *TInstant { - _cret := C.trgeometry_to_tinstant(temp._inner) +// TrgeometryAsTinstant wraps MEOS C function trgeometry_as_tinstant. +func TrgeometryAsTinstant(temp *Temporal) *TInstant { + _cret := C.trgeometry_as_tinstant(temp._inner) return &TInstant{_inner: _cret} } +// TrgeometryAsTsequence wraps MEOS C function trgeometry_as_tsequence. +func TrgeometryAsTsequence(temp *Temporal, interp_str string) *TSequence { + _c_interp_str := C.CString(interp_str) + defer C.free(unsafe.Pointer(_c_interp_str)) + _cret := C.trgeometry_as_tsequence(temp._inner, _c_interp_str) + return &TSequence{_inner: _cret} +} + + +// TrgeometryAsTsequenceset wraps MEOS C function trgeometry_as_tsequenceset. +func TrgeometryAsTsequenceset(temp *Temporal, interp_str string) *TSequenceSet { + _c_interp_str := C.CString(interp_str) + defer C.free(unsafe.Pointer(_c_interp_str)) + _cret := C.trgeometry_as_tsequenceset(temp._inner, _c_interp_str) + return &TSequenceSet{_inner: _cret} +} + + // TrgeometryAfterTimestamptz wraps MEOS C function trgeometry_after_timestamptz. func TrgeometryAfterTimestamptz(temp *Temporal, t int64, strict bool) *Temporal { _cret := C.trgeometry_after_timestamptz(temp._inner, C.TimestampTz(t), C.bool(strict)) @@ -499,6 +570,90 @@ func TrgeometryMinusSTBOX(temp *Temporal, box *STBox, border_inc bool) *Temporal } +// TrgeometryAtValue wraps MEOS C function trgeometry_at_value. +func TrgeometryAtValue(temp *Temporal, pose *Pose) *Temporal { + _cret := C.trgeometry_at_value(temp._inner, pose._inner) + return &Temporal{_inner: _cret} +} + + +// TrgeometryMinusValue wraps MEOS C function trgeometry_minus_value. +func TrgeometryMinusValue(temp *Temporal, pose *Pose) *Temporal { + _cret := C.trgeometry_minus_value(temp._inner, pose._inner) + return &Temporal{_inner: _cret} +} + + +// TrgeometryAtValues wraps MEOS C function trgeometry_at_values. +func TrgeometryAtValues(temp *Temporal, s *Set) *Temporal { + _cret := C.trgeometry_at_values(temp._inner, s._inner) + return &Temporal{_inner: _cret} +} + + +// TrgeometryMinusValues wraps MEOS C function trgeometry_minus_values. +func TrgeometryMinusValues(temp *Temporal, s *Set) *Temporal { + _cret := C.trgeometry_minus_values(temp._inner, s._inner) + return &Temporal{_inner: _cret} +} + + +// TrgeometryAtTimestamptz wraps MEOS C function trgeometry_at_timestamptz. +func TrgeometryAtTimestamptz(temp *Temporal, t int64) *Temporal { + _cret := C.trgeometry_at_timestamptz(temp._inner, C.TimestampTz(t)) + return &Temporal{_inner: _cret} +} + + +// TrgeometryMinusTimestamptz wraps MEOS C function trgeometry_minus_timestamptz. +func TrgeometryMinusTimestamptz(temp *Temporal, t int64) *Temporal { + _cret := C.trgeometry_minus_timestamptz(temp._inner, C.TimestampTz(t)) + return &Temporal{_inner: _cret} +} + + +// TrgeometryAtTstzset wraps MEOS C function trgeometry_at_tstzset. +func TrgeometryAtTstzset(temp *Temporal, s *Set) *Temporal { + _cret := C.trgeometry_at_tstzset(temp._inner, s._inner) + return &Temporal{_inner: _cret} +} + + +// TrgeometryMinusTstzset wraps MEOS C function trgeometry_minus_tstzset. +func TrgeometryMinusTstzset(temp *Temporal, s *Set) *Temporal { + _cret := C.trgeometry_minus_tstzset(temp._inner, s._inner) + return &Temporal{_inner: _cret} +} + + +// TrgeometryAtTstzspan wraps MEOS C function trgeometry_at_tstzspan. +func TrgeometryAtTstzspan(temp *Temporal, s *Span) *Temporal { + _cret := C.trgeometry_at_tstzspan(temp._inner, s._inner) + return &Temporal{_inner: _cret} +} + + +// TrgeometryMinusTstzspan wraps MEOS C function trgeometry_minus_tstzspan. +func TrgeometryMinusTstzspan(temp *Temporal, s *Span) *Temporal { + _cret := C.trgeometry_minus_tstzspan(temp._inner, s._inner) + return &Temporal{_inner: _cret} +} + + +// TrgeometryAtTstzspanset wraps MEOS C function trgeometry_at_tstzspanset. +func TrgeometryAtTstzspanset(temp *Temporal, ss *SpanSet) *Temporal { + _cret := C.trgeometry_at_tstzspanset(temp._inner, ss._inner) + return &Temporal{_inner: _cret} +} + + +// TrgeometryMinusTstzspanset wraps MEOS C function trgeometry_minus_tstzspanset. +func TrgeometryMinusTstzspanset(temp *Temporal, ss *SpanSet) *Temporal { + _cret := C.trgeometry_minus_tstzspanset(temp._inner, ss._inner) + return &Temporal{_inner: _cret} +} + + // TdistanceTrgeometryGeo wraps MEOS C function tdistance_trgeometry_geo. func TdistanceTrgeometryGeo(temp *Temporal, gs *Geom) *Temporal { _cret := C.tdistance_trgeometry_geo(temp._inner, gs._inner) diff --git a/functions/types.go b/functions/types.go index 3e86364..3c54b13 100644 --- a/functions/types.go +++ b/functions/types.go @@ -106,6 +106,11 @@ const ( RTreeSearchOp_RTREE_CONTAINS RTreeSearchOp = 1 RTreeSearchOp_RTREE_CONTAINED_BY RTreeSearchOp = 2 ) +type SPTreeKind C.SPTreeKind +const ( + SPTreeKind_SPTREE_QUADTREE SPTreeKind = 0 + SPTreeKind_SPTREE_KDTREE SPTreeKind = 1 +) type MeosType C.MeosType const ( MeosType_T_UNKNOWN MeosType = 0 diff --git a/tools/codegen.py b/tools/codegen.py index cc83e02..ce5ab93 100644 --- a/tools/codegen.py +++ b/tools/codegen.py @@ -953,17 +953,26 @@ def _todo_stub(c_name: str, reason: str) -> str: _CGO_FILE = """package functions /* -// Every optional MEOS family is enabled so the ``#if ``-guarded -// declarations in the core headers (e.g. meos_initialize_pointcloud) are -// visible -- matching the all-families libmeos the catalog is derived from, in -// sync with MobilityDB CMakeLists.txt's ``if(ALL)`` loop (alphabetical). The -// families expose external library types (H3's h3api.h) through their own -// headers, so their include dirs are added too. -#cgo darwin CFLAGS: -I/opt/homebrew/include -I/opt/homebrew/include/h3 -DMEOS=1 -DCBUFFER=1 -DH3=1 -DJSON=1 -DNPOINT=1 -DPOINTCLOUD=1 -DPOSE=1 -DQUADBIN=1 -DRASTER=1 -DRGEO=1 -#cgo darwin LDFLAGS: -L/opt/homebrew/lib -lmeos -Wl,-rpath,/opt/homebrew/lib - -#cgo linux CFLAGS: -I/usr/local/include/ -I/usr/include/h3 -DMEOS=1 -DCBUFFER=1 -DH3=1 -DJSON=1 -DNPOINT=1 -DPOINTCLOUD=1 -DPOSE=1 -DQUADBIN=1 -DRASTER=1 -DRGEO=1 -#cgo linux LDFLAGS: -L/usr/local/lib -lmeos -Wl,-rpath,/usr/local/lib +// The installed libmeos describes itself: `pkg-config --cflags meos` reports +// its include dir together with the family macros it is compiled with, and +// `--libs` reports where to link it from. Both matter, because the public +// headers gate declarations on those macros (meos.h holds #if MEOS, #if +// POINTCLOUD and #if JSON blocks), so a hand-kept -D list that disagrees with +// the library either declares a symbol that cannot link or hides a family the +// library provides. +// +// Asking pkg-config also makes the binding relocatable: PKG_CONFIG_PATH selects +// which libmeos to build against, so a build points at a private prefix rather +// than inheriting whatever occupies a machine-wide directory. A prefix outside +// the loader's default search path needs LD_LIBRARY_PATH (or ldconfig). +#cgo pkg-config: meos + +// H3 ships no pkg-config file, so the one dependency whose header the public +// MEOS headers expose (meos_h3.h includes ) names its include dir +// here. GEOS and GSL, the other exposed dependencies, resolve from the default +// include path. +#cgo darwin CFLAGS: -I/opt/homebrew/include/h3 +#cgo linux CFLAGS: -I/usr/include/h3 #include #include "meos.h"