From 90a4c6e08b0b1c552e4c9e17f0ec42bd9066675a Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Sat, 15 Aug 2026 14:14:06 +0200 Subject: [PATCH 1/2] 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" From 5114d58fca398ab68fe51877f7e8ea75e20838ba Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Sat, 15 Aug 2026 14:14:32 +0200 Subject: [PATCH 2/2] Return the MEOS error alongside every generated Go value A MEOS call reports failure out of band, and returns a sentinel that is the maximum of its own return type. The generated wrappers dropped that channel: TemporalNumInstants returned a bare int, so a rejected argument reached the caller as INT_MAX, a plausible count. No sentinel can carry the answer by itself -- INT_MAX is a count, DBL_MAX is a distance, and a bool has no spare value at all, so its failure is indistinguishable from a definite false. Each wrapper resets the errno, calls, and returns the error alongside its value, which is Go's idiom for the channel. The results are named so one guard shape serves every signature rather than a per-type zero value. All 3314 emitted wrappers carry it, with no per-function exception: an exception would need a hand-maintained list and the property would stop being checkable. The 30 Inner() accessors and the two error helpers touch no MEOS call and keep their signatures. The errno accessors join the skip list, being the plumbing this is built on: a generated MeosErrno() would reset the errno immediately before reading it and so always report success. --- functions/cgo.go | 33 + functions/meos_meos.go | 10885 +++++++++++++++++++------- functions/meos_meos_catalog.go | 632 +- functions/meos_meos_cbuffer.go | 1520 +++- functions/meos_meos_geo.go | 3576 ++++++--- functions/meos_meos_h3.go | 592 +- functions/meos_meos_internal.go | 2025 +++-- functions/meos_meos_internal_geo.go | 616 +- functions/meos_meos_json.go | 1472 +++- functions/meos_meos_npoint.go | 1024 ++- functions/meos_meos_pointcloud.go | 1517 +++- functions/meos_meos_pose.go | 1008 ++- functions/meos_meos_quadbin.go | 528 +- functions/meos_meos_rgeo.go | 1040 ++- tools/codegen.py | 101 +- 15 files changed, 20004 insertions(+), 6565 deletions(-) diff --git a/functions/cgo.go b/functions/cgo.go index 9ec333c..572c26b 100644 --- a/functions/cgo.go +++ b/functions/cgo.go @@ -38,3 +38,36 @@ package functions #include "meos_pointcloud.h" */ import "C" + +import "fmt" + +// MeosError reports that the MEOS call behind a wrapper failed, carrying the +// error code MEOS recorded for it. +type MeosError struct { + Code int +} + +func (e *MeosError) Error() string { + return fmt.Sprintf("meos: error %d", e.Code) +} + +// meosError reads the out-of-band state MEOS sets when a call fails, and +// clears it so a stale code cannot condemn the next, innocent call. It +// returns nil when the call succeeded. +// +// The returned value can never answer this on its own: every MEOS sentinel is +// a legitimate value of its own return type -- INT_MAX is a count, DBL_MAX is +// a distance, and a bool has no spare value at all. So no generated wrapper +// compares against a sentinel; each consults this instead. +// +// Install meos_initialize_noexit_error_handler (wrapped as +// MeosInitializeNoexitErrorHandler) once per process before calling anything +// else, on every thread that calls MEOS: the default handler ends the +// process, and meos_initialize resets the handler per thread. +func meosError() error { + if code := int(C.meos_errno()); code != 0 { + C.meos_errno_reset() + return &MeosError{Code: code} + } + return nil +} diff --git a/functions/meos_meos.go b/functions/meos_meos.go index dc34e53..4d7b2d6 100644 --- a/functions/meos_meos.go +++ b/functions/meos_meos.go @@ -86,185 +86,303 @@ import ( var _ = unsafe.Pointer(nil) // MeosArrayCreate wraps MEOS C function meos_array_create. -func MeosArrayCreate(elem_size int) *MeosArray { +func MeosArrayCreate(elem_size int) (_r0 *MeosArray, _err error) { + C.meos_errno_reset() _cret := C.meos_array_create(C.int(elem_size)) - return &MeosArray{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &MeosArray{_inner: _cret}, nil } // MeosArrayAdd wraps MEOS C function meos_array_add. -func MeosArrayAdd(array *MeosArray, value unsafe.Pointer) { +func MeosArrayAdd(array *MeosArray, value unsafe.Pointer) (_err error) { + C.meos_errno_reset() C.meos_array_add(array._inner, unsafe.Pointer(value)) + if _err = meosError(); _err != nil { + return + } + return nil } // MeosArrayGet wraps MEOS C function meos_array_get. -func MeosArrayGet(array *MeosArray, n int) unsafe.Pointer { +func MeosArrayGet(array *MeosArray, n int) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.meos_array_get(array._inner, C.int(n)) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // MeosArrayCount wraps MEOS C function meos_array_count. -func MeosArrayCount(array *MeosArray) int { +func MeosArrayCount(array *MeosArray) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.meos_array_count(array._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // MeosArrayReset wraps MEOS C function meos_array_reset. -func MeosArrayReset(array *MeosArray) { +func MeosArrayReset(array *MeosArray) (_err error) { + C.meos_errno_reset() C.meos_array_reset(array._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // MeosArrayResetFree wraps MEOS C function meos_array_reset_free. -func MeosArrayResetFree(array *MeosArray) { +func MeosArrayResetFree(array *MeosArray) (_err error) { + C.meos_errno_reset() C.meos_array_reset_free(array._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // MeosArrayDestroy wraps MEOS C function meos_array_destroy. -func MeosArrayDestroy(array *MeosArray) { +func MeosArrayDestroy(array *MeosArray) (_err error) { + C.meos_errno_reset() C.meos_array_destroy(array._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // MeosArrayDestroyFree wraps MEOS C function meos_array_destroy_free. -func MeosArrayDestroyFree(array *MeosArray) { +func MeosArrayDestroyFree(array *MeosArray) (_err error) { + C.meos_errno_reset() C.meos_array_destroy_free(array._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // RtreeCreateIntspan wraps MEOS C function rtree_create_intspan. -func RtreeCreateIntspan() *RTree { +func RtreeCreateIntspan() (_r0 *RTree, _err error) { + C.meos_errno_reset() _cret := C.rtree_create_intspan() - return &RTree{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &RTree{_inner: _cret}, nil } // RtreeCreateBigintspan wraps MEOS C function rtree_create_bigintspan. -func RtreeCreateBigintspan() *RTree { +func RtreeCreateBigintspan() (_r0 *RTree, _err error) { + C.meos_errno_reset() _cret := C.rtree_create_bigintspan() - return &RTree{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &RTree{_inner: _cret}, nil } // RtreeCreateFloatspan wraps MEOS C function rtree_create_floatspan. -func RtreeCreateFloatspan() *RTree { +func RtreeCreateFloatspan() (_r0 *RTree, _err error) { + C.meos_errno_reset() _cret := C.rtree_create_floatspan() - return &RTree{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &RTree{_inner: _cret}, nil } // RtreeCreateDatespan wraps MEOS C function rtree_create_datespan. -func RtreeCreateDatespan() *RTree { +func RtreeCreateDatespan() (_r0 *RTree, _err error) { + C.meos_errno_reset() _cret := C.rtree_create_datespan() - return &RTree{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &RTree{_inner: _cret}, nil } // RtreeCreateTstzspan wraps MEOS C function rtree_create_tstzspan. -func RtreeCreateTstzspan() *RTree { +func RtreeCreateTstzspan() (_r0 *RTree, _err error) { + C.meos_errno_reset() _cret := C.rtree_create_tstzspan() - return &RTree{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &RTree{_inner: _cret}, nil } // RtreeCreateTBOX wraps MEOS C function rtree_create_tbox. -func RtreeCreateTBOX() *RTree { +func RtreeCreateTBOX() (_r0 *RTree, _err error) { + C.meos_errno_reset() _cret := C.rtree_create_tbox() - return &RTree{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &RTree{_inner: _cret}, nil } // RtreeCreateSTBOX wraps MEOS C function rtree_create_stbox. -func RtreeCreateSTBOX() *RTree { +func RtreeCreateSTBOX() (_r0 *RTree, _err error) { + C.meos_errno_reset() _cret := C.rtree_create_stbox() - return &RTree{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &RTree{_inner: _cret}, nil } // RtreeCreateTpcbox wraps MEOS C function rtree_create_tpcbox. -func RtreeCreateTpcbox() *RTree { +func RtreeCreateTpcbox() (_r0 *RTree, _err error) { + C.meos_errno_reset() _cret := C.rtree_create_tpcbox() - return &RTree{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &RTree{_inner: _cret}, nil } // RtreeFree wraps MEOS C function rtree_free. -func RtreeFree(rtree *RTree) { +func RtreeFree(rtree *RTree) (_err error) { + C.meos_errno_reset() C.rtree_free(rtree._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // RtreeInsert wraps MEOS C function rtree_insert. -func RtreeInsert(rtree *RTree, box unsafe.Pointer, id int) { +func RtreeInsert(rtree *RTree, box unsafe.Pointer, id int) (_err error) { + C.meos_errno_reset() C.rtree_insert(rtree._inner, unsafe.Pointer(box), C.int(id)) + if _err = meosError(); _err != nil { + return + } + return nil } // RtreeInsertTemporal wraps MEOS C function rtree_insert_temporal. -func RtreeInsertTemporal(rtree *RTree, temp *Temporal, id int) { +func RtreeInsertTemporal(rtree *RTree, temp *Temporal, id int) (_err error) { + C.meos_errno_reset() C.rtree_insert_temporal(rtree._inner, temp._inner, C.int(id)) + if _err = meosError(); _err != nil { + return + } + return nil } // RtreeInsertTemporalSplit wraps MEOS C function rtree_insert_temporal_split. -func RtreeInsertTemporalSplit(rtree *RTree, temp *Temporal, id int, maxboxes int) { +func RtreeInsertTemporalSplit(rtree *RTree, temp *Temporal, id int, maxboxes int) (_err error) { + C.meos_errno_reset() C.rtree_insert_temporal_split(rtree._inner, temp._inner, C.int(id), C.int(maxboxes)) + if _err = meosError(); _err != nil { + return + } + return nil } // RtreeSearch wraps MEOS C function rtree_search. -func RtreeSearch(rtree *RTree, op RTreeSearchOp, query unsafe.Pointer) (int, *MeosArray) { +func RtreeSearch(rtree *RTree, op RTreeSearchOp, query unsafe.Pointer) (_r0 int, _r1 *MeosArray, _err error) { var _out_result C.MeosArray + C.meos_errno_reset() _cret := C.rtree_search(rtree._inner, C.RTreeSearchOp(op), unsafe.Pointer(query), &_out_result) - return int(_cret), &MeosArray{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return int(_cret), &MeosArray{_inner: &_out_result}, nil } // RtreeJoin wraps MEOS C function rtree_join. -func RtreeJoin(rtree1 *RTree, rtree2 *RTree, op RTreeSearchOp) (int, *MeosArray) { +func RtreeJoin(rtree1 *RTree, rtree2 *RTree, op RTreeSearchOp) (_r0 int, _r1 *MeosArray, _err error) { var _out_result C.MeosArray + C.meos_errno_reset() _cret := C.rtree_join(rtree1._inner, rtree2._inner, C.RTreeSearchOp(op), &_out_result) - return int(_cret), &MeosArray{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return int(_cret), &MeosArray{_inner: &_out_result}, nil } // RtreeSearchTemporal wraps MEOS C function rtree_search_temporal. -func RtreeSearchTemporal(rtree *RTree, op RTreeSearchOp, temp *Temporal) (int, *MeosArray) { +func RtreeSearchTemporal(rtree *RTree, op RTreeSearchOp, temp *Temporal) (_r0 int, _r1 *MeosArray, _err error) { var _out_result C.MeosArray + C.meos_errno_reset() _cret := C.rtree_search_temporal(rtree._inner, C.RTreeSearchOp(op), temp._inner, &_out_result) - return int(_cret), &MeosArray{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return int(_cret), &MeosArray{_inner: &_out_result}, nil } // RtreeSearchTemporalDedup wraps MEOS C function rtree_search_temporal_dedup. -func RtreeSearchTemporalDedup(rtree *RTree, op RTreeSearchOp, temp *Temporal, maxboxes int) (int, *MeosArray) { +func RtreeSearchTemporalDedup(rtree *RTree, op RTreeSearchOp, temp *Temporal, maxboxes int) (_r0 int, _r1 *MeosArray, _err error) { var _out_result C.MeosArray + C.meos_errno_reset() _cret := C.rtree_search_temporal_dedup(rtree._inner, C.RTreeSearchOp(op), temp._inner, C.int(maxboxes), &_out_result) - return int(_cret), &MeosArray{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return int(_cret), &MeosArray{_inner: &_out_result}, nil } // RtreeNnCursorOpen wraps MEOS C function rtree_nn_cursor_open. -func RtreeNnCursorOpen(rtree *RTree, query unsafe.Pointer) unsafe.Pointer { +func RtreeNnCursorOpen(rtree *RTree, query unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.rtree_nn_cursor_open(rtree._inner, unsafe.Pointer(query)) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // RtreeNnCursorNext wraps MEOS C function rtree_nn_cursor_next. -func RtreeNnCursorNext(cursor unsafe.Pointer, id_out unsafe.Pointer, dist_out unsafe.Pointer) bool { +func RtreeNnCursorNext(cursor unsafe.Pointer, id_out unsafe.Pointer, dist_out unsafe.Pointer) (_r0 bool, _err error) { + C.meos_errno_reset() _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) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RtreeNnCursorClose wraps MEOS C function rtree_nn_cursor_close. -func RtreeNnCursorClose(cursor unsafe.Pointer) { +func RtreeNnCursorClose(cursor unsafe.Pointer) (_err error) { + C.meos_errno_reset() C.rtree_nn_cursor_close((*C.RTreeNNCursor)(unsafe.Pointer(cursor))) + if _err = meosError(); _err != nil { + return + } + return nil } @@ -301,70 +419,115 @@ func RtreeNnCursorClose(cursor unsafe.Pointer) { // SptreeFree wraps MEOS C function sptree_free. -func SptreeFree(sptree unsafe.Pointer) { +func SptreeFree(sptree unsafe.Pointer) (_err error) { + C.meos_errno_reset() C.sptree_free((*C.SPTree)(unsafe.Pointer(sptree))) + if _err = meosError(); _err != nil { + return + } + return nil } // SptreeInsert wraps MEOS C function sptree_insert. -func SptreeInsert(sptree unsafe.Pointer, box unsafe.Pointer, id int) { +func SptreeInsert(sptree unsafe.Pointer, box unsafe.Pointer, id int) (_err error) { + C.meos_errno_reset() C.sptree_insert((*C.SPTree)(unsafe.Pointer(sptree)), unsafe.Pointer(box), C.int(id)) + if _err = meosError(); _err != nil { + return + } + return nil } // SptreeInsertTemporal wraps MEOS C function sptree_insert_temporal. -func SptreeInsertTemporal(sptree unsafe.Pointer, temp *Temporal, id int) { +func SptreeInsertTemporal(sptree unsafe.Pointer, temp *Temporal, id int) (_err error) { + C.meos_errno_reset() C.sptree_insert_temporal((*C.SPTree)(unsafe.Pointer(sptree)), temp._inner, C.int(id)) + if _err = meosError(); _err != nil { + return + } + return nil } // SptreeInsertTemporalSplit wraps MEOS C function sptree_insert_temporal_split. -func SptreeInsertTemporalSplit(sptree unsafe.Pointer, temp *Temporal, id int, maxboxes int) { +func SptreeInsertTemporalSplit(sptree unsafe.Pointer, temp *Temporal, id int, maxboxes int) (_err error) { + C.meos_errno_reset() C.sptree_insert_temporal_split((*C.SPTree)(unsafe.Pointer(sptree)), temp._inner, C.int(id), C.int(maxboxes)) + if _err = meosError(); _err != nil { + return + } + return nil } // SptreeSearch wraps MEOS C function sptree_search. -func SptreeSearch(sptree unsafe.Pointer, op RTreeSearchOp, query unsafe.Pointer) (int, *MeosArray) { +func SptreeSearch(sptree unsafe.Pointer, op RTreeSearchOp, query unsafe.Pointer) (_r0 int, _r1 *MeosArray, _err error) { var _out_result C.MeosArray + C.meos_errno_reset() _cret := C.sptree_search((*C.SPTree)(unsafe.Pointer(sptree)), C.RTreeSearchOp(op), unsafe.Pointer(query), &_out_result) - return int(_cret), &MeosArray{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return int(_cret), &MeosArray{_inner: &_out_result}, nil } // SptreeSearchTemporal wraps MEOS C function sptree_search_temporal. -func SptreeSearchTemporal(sptree unsafe.Pointer, op RTreeSearchOp, temp *Temporal) (int, *MeosArray) { +func SptreeSearchTemporal(sptree unsafe.Pointer, op RTreeSearchOp, temp *Temporal) (_r0 int, _r1 *MeosArray, _err error) { var _out_result C.MeosArray + C.meos_errno_reset() _cret := C.sptree_search_temporal((*C.SPTree)(unsafe.Pointer(sptree)), C.RTreeSearchOp(op), temp._inner, &_out_result) - return int(_cret), &MeosArray{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return int(_cret), &MeosArray{_inner: &_out_result}, nil } // SptreeSearchTemporalDedup wraps MEOS C function sptree_search_temporal_dedup. -func SptreeSearchTemporalDedup(sptree unsafe.Pointer, op RTreeSearchOp, temp *Temporal, maxboxes int) (int, *MeosArray) { +func SptreeSearchTemporalDedup(sptree unsafe.Pointer, op RTreeSearchOp, temp *Temporal, maxboxes int) (_r0 int, _r1 *MeosArray, _err error) { var _out_result C.MeosArray + C.meos_errno_reset() _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} + if _err = meosError(); _err != nil { + return + } + return int(_cret), &MeosArray{_inner: &_out_result}, nil } // SptreeNnCursorOpen wraps MEOS C function sptree_nn_cursor_open. -func SptreeNnCursorOpen(sptree unsafe.Pointer, query unsafe.Pointer) unsafe.Pointer { +func SptreeNnCursorOpen(sptree unsafe.Pointer, query unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.sptree_nn_cursor_open((*C.SPTree)(unsafe.Pointer(sptree)), unsafe.Pointer(query)) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // SptreeNnCursorNext wraps MEOS C function sptree_nn_cursor_next. -func SptreeNnCursorNext(cursor unsafe.Pointer, id_out unsafe.Pointer, dist_out unsafe.Pointer) bool { +func SptreeNnCursorNext(cursor unsafe.Pointer, id_out unsafe.Pointer, dist_out unsafe.Pointer) (_r0 bool, _err error) { + C.meos_errno_reset() _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) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SptreeNnCursorClose wraps MEOS C function sptree_nn_cursor_close. -func SptreeNnCursorClose(cursor unsafe.Pointer) { +func SptreeNnCursorClose(cursor unsafe.Pointer) (_err error) { + C.meos_errno_reset() C.sptree_nn_cursor_close((*C.SPNNCursor)(unsafe.Pointer(cursor))) + if _err = meosError(); _err != nil { + return + } + return nil } @@ -373,9519 +536,14839 @@ func SptreeNnCursorClose(cursor unsafe.Pointer) { // MeosInitializeNoexitErrorHandler wraps MEOS C function meos_initialize_noexit_error_handler. -func MeosInitializeNoexitErrorHandler() { +func MeosInitializeNoexitErrorHandler() (_err error) { + C.meos_errno_reset() C.meos_initialize_noexit_error_handler() + if _err = meosError(); _err != nil { + return + } + return nil } // MeosInitializeTimezone wraps MEOS C function meos_initialize_timezone. -func MeosInitializeTimezone(name string) { +func MeosInitializeTimezone(name string) (_err error) { _c_name := C.CString(name) defer C.free(unsafe.Pointer(_c_name)) + C.meos_errno_reset() C.meos_initialize_timezone(_c_name) + if _err = meosError(); _err != nil { + return + } + return nil } // MeosInitializeCollation wraps MEOS C function meos_initialize_collation. -func MeosInitializeCollation() { +func MeosInitializeCollation() (_err error) { + C.meos_errno_reset() C.meos_initialize_collation() + if _err = meosError(); _err != nil { + return + } + return nil } // MeosFinalizeTimezone wraps MEOS C function meos_finalize_timezone. -func MeosFinalizeTimezone() { +func MeosFinalizeTimezone() (_err error) { + C.meos_errno_reset() C.meos_finalize_timezone() + if _err = meosError(); _err != nil { + return + } + return nil } // MeosFinalizeCollation wraps MEOS C function meos_finalize_collation. -func MeosFinalizeCollation() { +func MeosFinalizeCollation() (_err error) { + C.meos_errno_reset() C.meos_finalize_collation() + if _err = meosError(); _err != nil { + return + } + return nil } // MeosFinalizeProjsrs wraps MEOS C function meos_finalize_projsrs. -func MeosFinalizeProjsrs() { +func MeosFinalizeProjsrs() (_err error) { + C.meos_errno_reset() C.meos_finalize_projsrs() + if _err = meosError(); _err != nil { + return + } + return nil } // MeosFinalizeWays wraps MEOS C function meos_finalize_ways. -func MeosFinalizeWays() { +func MeosFinalizeWays() (_err error) { + C.meos_errno_reset() C.meos_finalize_ways() + if _err = meosError(); _err != nil { + return + } + return nil } // MeosInitializePointcloud wraps MEOS C function meos_initialize_pointcloud. -func MeosInitializePointcloud() { +func MeosInitializePointcloud() (_err error) { + C.meos_errno_reset() C.meos_initialize_pointcloud() + if _err = meosError(); _err != nil { + return + } + return nil } // MeosSetDatestyle wraps MEOS C function meos_set_datestyle. -func MeosSetDatestyle(newval string, extra unsafe.Pointer) bool { +func MeosSetDatestyle(newval string, extra unsafe.Pointer) (_r0 bool, _err error) { _c_newval := C.CString(newval) defer C.free(unsafe.Pointer(_c_newval)) + C.meos_errno_reset() _cret := C.meos_set_datestyle(_c_newval, unsafe.Pointer(extra)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // MeosSetIntervalstyle wraps MEOS C function meos_set_intervalstyle. -func MeosSetIntervalstyle(newval string, extra int) bool { +func MeosSetIntervalstyle(newval string, extra int) (_r0 bool, _err error) { _c_newval := C.CString(newval) defer C.free(unsafe.Pointer(_c_newval)) + C.meos_errno_reset() _cret := C.meos_set_intervalstyle(_c_newval, C.int(extra)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // MeosGetDatestyle wraps MEOS C function meos_get_datestyle. -func MeosGetDatestyle() string { +func MeosGetDatestyle() (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.meos_get_datestyle() - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // MeosGetIntervalstyle wraps MEOS C function meos_get_intervalstyle. -func MeosGetIntervalstyle() string { +func MeosGetIntervalstyle() (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.meos_get_intervalstyle() - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // MeosSetSpatialRefSysCsv wraps MEOS C function meos_set_spatial_ref_sys_csv. -func MeosSetSpatialRefSysCsv(path string) { +func MeosSetSpatialRefSysCsv(path string) (_err error) { _c_path := C.CString(path) defer C.free(unsafe.Pointer(_c_path)) + C.meos_errno_reset() C.meos_set_spatial_ref_sys_csv(_c_path) + if _err = meosError(); _err != nil { + return + } + return nil } // MeosSetWaysCsv wraps MEOS C function meos_set_ways_csv. -func MeosSetWaysCsv(path string) { +func MeosSetWaysCsv(path string) (_err error) { _c_path := C.CString(path) defer C.free(unsafe.Pointer(_c_path)) + C.meos_errno_reset() C.meos_set_ways_csv(_c_path) + if _err = meosError(); _err != nil { + return + } + return nil } // MeosInitialize wraps MEOS C function meos_initialize. -func MeosInitialize() { +func MeosInitialize() (_err error) { + C.meos_errno_reset() C.meos_initialize() + if _err = meosError(); _err != nil { + return + } + return nil } // MeosFinalize wraps MEOS C function meos_finalize. -func MeosFinalize() { +func MeosFinalize() (_err error) { + C.meos_errno_reset() C.meos_finalize() + if _err = meosError(); _err != nil { + return + } + return nil } // MeosVersion wraps MEOS C function meos_version. -func MeosVersion() string { +func MeosVersion() (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.meos_version() - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // MeosFullVersion wraps MEOS C function meos_full_version. -func MeosFullVersion() string { +func MeosFullVersion() (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.meos_full_version() - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // MobilitydbVersion wraps MEOS C function mobilitydb_version. -func MobilitydbVersion() string { +func MobilitydbVersion() (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.mobilitydb_version() - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // MobilitydbFullVersion wraps MEOS C function mobilitydb_full_version. -func MobilitydbFullVersion() string { +func MobilitydbFullVersion() (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.mobilitydb_full_version() - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // BigintsetIn wraps MEOS C function bigintset_in. -func BigintsetIn(str string) *Set { +func BigintsetIn(str string) (_r0 *Set, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.bigintset_in(_c_str) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // BigintsetOut wraps MEOS C function bigintset_out. -func BigintsetOut(set *Set) string { +func BigintsetOut(set *Set) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.bigintset_out(set._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // BigintspanExpand wraps MEOS C function bigintspan_expand. -func BigintspanExpand(s *Span, value int64) *Span { +func BigintspanExpand(s *Span, value int64) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.bigintspan_expand(s._inner, C.int64_t(value)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // BigintspanIn wraps MEOS C function bigintspan_in. -func BigintspanIn(str string) *Span { +func BigintspanIn(str string) (_r0 *Span, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.bigintspan_in(_c_str) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // BigintspanOut wraps MEOS C function bigintspan_out. -func BigintspanOut(s *Span) string { +func BigintspanOut(s *Span) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.bigintspan_out(s._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // BigintspansetIn wraps MEOS C function bigintspanset_in. -func BigintspansetIn(str string) *SpanSet { +func BigintspansetIn(str string) (_r0 *SpanSet, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.bigintspanset_in(_c_str) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // BigintspansetOut wraps MEOS C function bigintspanset_out. -func BigintspansetOut(ss *SpanSet) string { +func BigintspansetOut(ss *SpanSet) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.bigintspanset_out(ss._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // DatesetIn wraps MEOS C function dateset_in. -func DatesetIn(str string) *Set { +func DatesetIn(str string) (_r0 *Set, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.dateset_in(_c_str) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // DatesetOut wraps MEOS C function dateset_out. -func DatesetOut(s *Set) string { +func DatesetOut(s *Set) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.dateset_out(s._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // DatespanIn wraps MEOS C function datespan_in. -func DatespanIn(str string) *Span { +func DatespanIn(str string) (_r0 *Span, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.datespan_in(_c_str) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // DatespanOut wraps MEOS C function datespan_out. -func DatespanOut(s *Span) string { +func DatespanOut(s *Span) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.datespan_out(s._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // DatespansetIn wraps MEOS C function datespanset_in. -func DatespansetIn(str string) *SpanSet { +func DatespansetIn(str string) (_r0 *SpanSet, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.datespanset_in(_c_str) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // DatespansetOut wraps MEOS C function datespanset_out. -func DatespansetOut(ss *SpanSet) string { +func DatespansetOut(ss *SpanSet) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.datespanset_out(ss._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // FloatsetIn wraps MEOS C function floatset_in. -func FloatsetIn(str string) *Set { +func FloatsetIn(str string) (_r0 *Set, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.floatset_in(_c_str) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // FloatsetOut wraps MEOS C function floatset_out. -func FloatsetOut(set *Set, maxdd int) string { +func FloatsetOut(set *Set, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.floatset_out(set._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // FloatspanExpand wraps MEOS C function floatspan_expand. -func FloatspanExpand(s *Span, value float64) *Span { +func FloatspanExpand(s *Span, value float64) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.floatspan_expand(s._inner, C.double(value)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // FloatspanIn wraps MEOS C function floatspan_in. -func FloatspanIn(str string) *Span { +func FloatspanIn(str string) (_r0 *Span, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.floatspan_in(_c_str) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // FloatspanOut wraps MEOS C function floatspan_out. -func FloatspanOut(s *Span, maxdd int) string { +func FloatspanOut(s *Span, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.floatspan_out(s._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // FloatspansetIn wraps MEOS C function floatspanset_in. -func FloatspansetIn(str string) *SpanSet { +func FloatspansetIn(str string) (_r0 *SpanSet, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.floatspanset_in(_c_str) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // FloatspansetOut wraps MEOS C function floatspanset_out. -func FloatspansetOut(ss *SpanSet, maxdd int) string { +func FloatspansetOut(ss *SpanSet, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.floatspanset_out(ss._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // IntsetIn wraps MEOS C function intset_in. -func IntsetIn(str string) *Set { +func IntsetIn(str string) (_r0 *Set, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.intset_in(_c_str) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntsetOut wraps MEOS C function intset_out. -func IntsetOut(set *Set) string { +func IntsetOut(set *Set) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.intset_out(set._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // IntspanExpand wraps MEOS C function intspan_expand. -func IntspanExpand(s *Span, value int32) *Span { +func IntspanExpand(s *Span, value int32) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.intspan_expand(s._inner, C.int32(value)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // IntspanIn wraps MEOS C function intspan_in. -func IntspanIn(str string) *Span { +func IntspanIn(str string) (_r0 *Span, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.intspan_in(_c_str) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // IntspanOut wraps MEOS C function intspan_out. -func IntspanOut(s *Span) string { +func IntspanOut(s *Span) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.intspan_out(s._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // IntspansetIn wraps MEOS C function intspanset_in. -func IntspansetIn(str string) *SpanSet { +func IntspansetIn(str string) (_r0 *SpanSet, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.intspanset_in(_c_str) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // IntspansetOut wraps MEOS C function intspanset_out. -func IntspansetOut(ss *SpanSet) string { +func IntspansetOut(ss *SpanSet) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.intspanset_out(ss._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // SetAsHexwkb wraps MEOS C function set_as_hexwkb. -func SetAsHexwkb(s *Set, variant uint8, size_out unsafe.Pointer) string { +func SetAsHexwkb(s *Set, variant uint8, size_out unsafe.Pointer) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.set_as_hexwkb(s._inner, C.uint8_t(variant), (*C.size_t)(unsafe.Pointer(size_out))) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // SetAsWKB wraps MEOS C function set_as_wkb. -func SetAsWKB(s *Set, variant uint8, size_out unsafe.Pointer) unsafe.Pointer { +func SetAsWKB(s *Set, variant uint8, size_out unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.set_as_wkb(s._inner, C.uint8_t(variant), (*C.size_t)(unsafe.Pointer(size_out))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // SetFromHexwkb wraps MEOS C function set_from_hexwkb. -func SetFromHexwkb(hexwkb string) *Set { +func SetFromHexwkb(hexwkb string) (_r0 *Set, _err error) { _c_hexwkb := C.CString(hexwkb) defer C.free(unsafe.Pointer(_c_hexwkb)) + C.meos_errno_reset() _cret := C.set_from_hexwkb(_c_hexwkb) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // SetFromWKB wraps MEOS C function set_from_wkb. -func SetFromWKB(wkb unsafe.Pointer, size uint) *Set { +func SetFromWKB(wkb unsafe.Pointer, size uint) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.set_from_wkb((*C.uint8_t)(unsafe.Pointer(wkb)), C.size_t(size)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // SpanAsHexwkb wraps MEOS C function span_as_hexwkb. -func SpanAsHexwkb(s *Span, variant uint8, size_out unsafe.Pointer) string { +func SpanAsHexwkb(s *Span, variant uint8, size_out unsafe.Pointer) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.span_as_hexwkb(s._inner, C.uint8_t(variant), (*C.size_t)(unsafe.Pointer(size_out))) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // SpanAsWKB wraps MEOS C function span_as_wkb. -func SpanAsWKB(s *Span, variant uint8, size_out unsafe.Pointer) unsafe.Pointer { +func SpanAsWKB(s *Span, variant uint8, size_out unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.span_as_wkb(s._inner, C.uint8_t(variant), (*C.size_t)(unsafe.Pointer(size_out))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // SpanFromHexwkb wraps MEOS C function span_from_hexwkb. -func SpanFromHexwkb(hexwkb string) *Span { +func SpanFromHexwkb(hexwkb string) (_r0 *Span, _err error) { _c_hexwkb := C.CString(hexwkb) defer C.free(unsafe.Pointer(_c_hexwkb)) + C.meos_errno_reset() _cret := C.span_from_hexwkb(_c_hexwkb) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // SpanFromWKB wraps MEOS C function span_from_wkb. -func SpanFromWKB(wkb unsafe.Pointer, size uint) *Span { +func SpanFromWKB(wkb unsafe.Pointer, size uint) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.span_from_wkb((*C.uint8_t)(unsafe.Pointer(wkb)), C.size_t(size)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // SpansetAsHexwkb wraps MEOS C function spanset_as_hexwkb. -func SpansetAsHexwkb(ss *SpanSet, variant uint8, size_out unsafe.Pointer) string { +func SpansetAsHexwkb(ss *SpanSet, variant uint8, size_out unsafe.Pointer) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.spanset_as_hexwkb(ss._inner, C.uint8_t(variant), (*C.size_t)(unsafe.Pointer(size_out))) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // SpansetAsWKB wraps MEOS C function spanset_as_wkb. -func SpansetAsWKB(ss *SpanSet, variant uint8, size_out unsafe.Pointer) unsafe.Pointer { +func SpansetAsWKB(ss *SpanSet, variant uint8, size_out unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.spanset_as_wkb(ss._inner, C.uint8_t(variant), (*C.size_t)(unsafe.Pointer(size_out))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // SpansetFromHexwkb wraps MEOS C function spanset_from_hexwkb. -func SpansetFromHexwkb(hexwkb string) *SpanSet { +func SpansetFromHexwkb(hexwkb string) (_r0 *SpanSet, _err error) { _c_hexwkb := C.CString(hexwkb) defer C.free(unsafe.Pointer(_c_hexwkb)) + C.meos_errno_reset() _cret := C.spanset_from_hexwkb(_c_hexwkb) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // SpansetFromWKB wraps MEOS C function spanset_from_wkb. -func SpansetFromWKB(wkb unsafe.Pointer, size uint) *SpanSet { +func SpansetFromWKB(wkb unsafe.Pointer, size uint) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.spanset_from_wkb((*C.uint8_t)(unsafe.Pointer(wkb)), C.size_t(size)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // TextsetIn wraps MEOS C function textset_in. -func TextsetIn(str string) *Set { +func TextsetIn(str string) (_r0 *Set, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.textset_in(_c_str) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TextsetOut wraps MEOS C function textset_out. -func TextsetOut(set *Set) string { +func TextsetOut(set *Set) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.textset_out(set._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TstzsetIn wraps MEOS C function tstzset_in. -func TstzsetIn(str string) *Set { +func TstzsetIn(str string) (_r0 *Set, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tstzset_in(_c_str) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TstzsetOut wraps MEOS C function tstzset_out. -func TstzsetOut(set *Set) string { +func TstzsetOut(set *Set) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.tstzset_out(set._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TstzspanIn wraps MEOS C function tstzspan_in. -func TstzspanIn(str string) *Span { +func TstzspanIn(str string) (_r0 *Span, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tstzspan_in(_c_str) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TstzspanOut wraps MEOS C function tstzspan_out. -func TstzspanOut(s *Span) string { +func TstzspanOut(s *Span) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.tstzspan_out(s._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TstzspansetIn wraps MEOS C function tstzspanset_in. -func TstzspansetIn(str string) *SpanSet { +func TstzspansetIn(str string) (_r0 *SpanSet, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tstzspanset_in(_c_str) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // TstzspansetOut wraps MEOS C function tstzspanset_out. -func TstzspansetOut(ss *SpanSet) string { +func TstzspansetOut(ss *SpanSet) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.tstzspanset_out(ss._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // BigintsetMake wraps MEOS C function bigintset_make. -func BigintsetMake(values unsafe.Pointer, count int) *Set { +func BigintsetMake(values unsafe.Pointer, count int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.bigintset_make((*C.int64_t)(unsafe.Pointer(values)), C.int(count)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // BigintspanMake wraps MEOS C function bigintspan_make. -func BigintspanMake(lower int64, upper int64, lower_inc bool, upper_inc bool) *Span { +func BigintspanMake(lower int64, upper int64, lower_inc bool, upper_inc bool) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.bigintspan_make(C.int64_t(lower), C.int64_t(upper), C.bool(lower_inc), C.bool(upper_inc)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // DatesetMake wraps MEOS C function dateset_make. -func DatesetMake(values unsafe.Pointer, count int) *Set { +func DatesetMake(values unsafe.Pointer, count int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.dateset_make((*C.DateADT)(unsafe.Pointer(values)), C.int(count)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // DatespanMake wraps MEOS C function datespan_make. -func DatespanMake(lower int32, upper int32, lower_inc bool, upper_inc bool) *Span { +func DatespanMake(lower int32, upper int32, lower_inc bool, upper_inc bool) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.datespan_make(C.DateADT(lower), C.DateADT(upper), C.bool(lower_inc), C.bool(upper_inc)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // FloatsetMake wraps MEOS C function floatset_make. -func FloatsetMake(values unsafe.Pointer, count int) *Set { +func FloatsetMake(values unsafe.Pointer, count int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.floatset_make((*C.double)(unsafe.Pointer(values)), C.int(count)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // FloatspanMake wraps MEOS C function floatspan_make. -func FloatspanMake(lower float64, upper float64, lower_inc bool, upper_inc bool) *Span { +func FloatspanMake(lower float64, upper float64, lower_inc bool, upper_inc bool) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.floatspan_make(C.double(lower), C.double(upper), C.bool(lower_inc), C.bool(upper_inc)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // IntsetMake wraps MEOS C function intset_make. -func IntsetMake(values unsafe.Pointer, count int) *Set { +func IntsetMake(values unsafe.Pointer, count int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intset_make((*C.int)(unsafe.Pointer(values)), C.int(count)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntspanMake wraps MEOS C function intspan_make. -func IntspanMake(lower int, upper int, lower_inc bool, upper_inc bool) *Span { +func IntspanMake(lower int, upper int, lower_inc bool, upper_inc bool) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.intspan_make(C.int(lower), C.int(upper), C.bool(lower_inc), C.bool(upper_inc)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // SetCopy wraps MEOS C function set_copy. -func SetCopy(s *Set) *Set { +func SetCopy(s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.set_copy(s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // SpanCopy wraps MEOS C function span_copy. -func SpanCopy(s *Span) *Span { +func SpanCopy(s *Span) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.span_copy(s._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // SpansetCopy wraps MEOS C function spanset_copy. -func SpansetCopy(ss *SpanSet) *SpanSet { +func SpansetCopy(ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.spanset_copy(ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // SpansetMake wraps MEOS C function spanset_make. -func SpansetMake(spans *Span, count int) *SpanSet { +func SpansetMake(spans *Span, count int) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.spanset_make(spans._inner, C.int(count)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // TextsetMake wraps MEOS C function textset_make. -func TextsetMake(values unsafe.Pointer, count int) *Set { +func TextsetMake(values unsafe.Pointer, count int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.textset_make((**C.text)(unsafe.Pointer(values)), C.int(count)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TstzsetMake wraps MEOS C function tstzset_make. -func TstzsetMake(values unsafe.Pointer, count int) *Set { +func TstzsetMake(values unsafe.Pointer, count int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.tstzset_make((*C.TimestampTz)(unsafe.Pointer(values)), C.int(count)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TstzspanMake wraps MEOS C function tstzspan_make. -func TstzspanMake(lower int64, upper int64, lower_inc bool, upper_inc bool) *Span { +func TstzspanMake(lower int64, upper int64, lower_inc bool, upper_inc bool) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.tstzspan_make(C.TimestampTz(lower), C.TimestampTz(upper), C.bool(lower_inc), C.bool(upper_inc)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // BigintToSet wraps MEOS C function bigint_to_set. -func BigintToSet(i int64) *Set { +func BigintToSet(i int64) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.bigint_to_set(C.int64_t(i)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // BigintToSpan wraps MEOS C function bigint_to_span. -func BigintToSpan(i int) *Span { +func BigintToSpan(i int) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.bigint_to_span(C.int(i)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // BigintToSpanset wraps MEOS C function bigint_to_spanset. -func BigintToSpanset(i int) *SpanSet { +func BigintToSpanset(i int) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.bigint_to_spanset(C.int(i)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // DateToSet wraps MEOS C function date_to_set. -func DateToSet(d int32) *Set { +func DateToSet(d int32) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.date_to_set(C.DateADT(d)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // DateToSpan wraps MEOS C function date_to_span. -func DateToSpan(d int32) *Span { +func DateToSpan(d int32) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.date_to_span(C.DateADT(d)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // DateToSpanset wraps MEOS C function date_to_spanset. -func DateToSpanset(d int32) *SpanSet { +func DateToSpanset(d int32) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.date_to_spanset(C.DateADT(d)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // DatesetToTstzset wraps MEOS C function dateset_to_tstzset. -func DatesetToTstzset(s *Set) *Set { +func DatesetToTstzset(s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.dateset_to_tstzset(s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // DatespanToTstzspan wraps MEOS C function datespan_to_tstzspan. -func DatespanToTstzspan(s *Span) *Span { +func DatespanToTstzspan(s *Span) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.datespan_to_tstzspan(s._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // DatespansetToTstzspanset wraps MEOS C function datespanset_to_tstzspanset. -func DatespansetToTstzspanset(ss *SpanSet) *SpanSet { +func DatespansetToTstzspanset(ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.datespanset_to_tstzspanset(ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // FloatToSet wraps MEOS C function float_to_set. -func FloatToSet(d float64) *Set { +func FloatToSet(d float64) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.float_to_set(C.double(d)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // FloatToSpan wraps MEOS C function float_to_span. -func FloatToSpan(d float64) *Span { +func FloatToSpan(d float64) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.float_to_span(C.double(d)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // FloatToSpanset wraps MEOS C function float_to_spanset. -func FloatToSpanset(d float64) *SpanSet { +func FloatToSpanset(d float64) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.float_to_spanset(C.double(d)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // FloatsetToIntset wraps MEOS C function floatset_to_intset. -func FloatsetToIntset(s *Set) *Set { +func FloatsetToIntset(s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.floatset_to_intset(s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // FloatspanToIntspan wraps MEOS C function floatspan_to_intspan. -func FloatspanToIntspan(s *Span) *Span { +func FloatspanToIntspan(s *Span) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.floatspan_to_intspan(s._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // FloatspanToBigintspan wraps MEOS C function floatspan_to_bigintspan. -func FloatspanToBigintspan(s *Span) *Span { +func FloatspanToBigintspan(s *Span) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.floatspan_to_bigintspan(s._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // FloatspansetToIntspanset wraps MEOS C function floatspanset_to_intspanset. -func FloatspansetToIntspanset(ss *SpanSet) *SpanSet { +func FloatspansetToIntspanset(ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.floatspanset_to_intspanset(ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // IntToSet wraps MEOS C function int_to_set. -func IntToSet(i int) *Set { +func IntToSet(i int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.int_to_set(C.int(i)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntToSpan wraps MEOS C function int_to_span. -func IntToSpan(i int) *Span { +func IntToSpan(i int) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.int_to_span(C.int(i)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // IntToSpanset wraps MEOS C function int_to_spanset. -func IntToSpanset(i int) *SpanSet { +func IntToSpanset(i int) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.int_to_spanset(C.int(i)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // IntsetToFloatset wraps MEOS C function intset_to_floatset. -func IntsetToFloatset(s *Set) *Set { +func IntsetToFloatset(s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intset_to_floatset(s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntspanToFloatspan wraps MEOS C function intspan_to_floatspan. -func IntspanToFloatspan(s *Span) *Span { +func IntspanToFloatspan(s *Span) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.intspan_to_floatspan(s._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // IntspanToBigintspan wraps MEOS C function intspan_to_bigintspan. -func IntspanToBigintspan(s *Span) *Span { +func IntspanToBigintspan(s *Span) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.intspan_to_bigintspan(s._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // BigintspanToIntspan wraps MEOS C function bigintspan_to_intspan. -func BigintspanToIntspan(s *Span) *Span { +func BigintspanToIntspan(s *Span) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.bigintspan_to_intspan(s._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // BigintspanToFloatspan wraps MEOS C function bigintspan_to_floatspan. -func BigintspanToFloatspan(s *Span) *Span { +func BigintspanToFloatspan(s *Span) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.bigintspan_to_floatspan(s._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // IntspansetToFloatspanset wraps MEOS C function intspanset_to_floatspanset. -func IntspansetToFloatspanset(ss *SpanSet) *SpanSet { +func IntspansetToFloatspanset(ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.intspanset_to_floatspanset(ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // SetToSpan wraps MEOS C function set_to_span. -func SetToSpan(s *Set) *Span { +func SetToSpan(s *Set) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.set_to_span(s._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // SetToSpanset wraps MEOS C function set_to_spanset. -func SetToSpanset(s *Set) *SpanSet { +func SetToSpanset(s *Set) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.set_to_spanset(s._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // SpanToSpanset wraps MEOS C function span_to_spanset. -func SpanToSpanset(s *Span) *SpanSet { +func SpanToSpanset(s *Span) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.span_to_spanset(s._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // TextToSet wraps MEOS C function text_to_set. -func TextToSet(txt string) *Set { +func TextToSet(txt string) (_r0 *Set, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.text_to_set(_c_txt) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TimestamptzToSet wraps MEOS C function timestamptz_to_set. -func TimestamptzToSet(t int64) *Set { +func TimestamptzToSet(t int64) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.timestamptz_to_set(C.TimestampTz(t)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TimestamptzToSpan wraps MEOS C function timestamptz_to_span. -func TimestamptzToSpan(t int64) *Span { +func TimestamptzToSpan(t int64) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.timestamptz_to_span(C.TimestampTz(t)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TimestamptzToSpanset wraps MEOS C function timestamptz_to_spanset. -func TimestamptzToSpanset(t int64) *SpanSet { +func TimestamptzToSpanset(t int64) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.timestamptz_to_spanset(C.TimestampTz(t)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // TstzsetToDateset wraps MEOS C function tstzset_to_dateset. -func TstzsetToDateset(s *Set) *Set { +func TstzsetToDateset(s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.tstzset_to_dateset(s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TstzspanToDatespan wraps MEOS C function tstzspan_to_datespan. -func TstzspanToDatespan(s *Span) *Span { +func TstzspanToDatespan(s *Span) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.tstzspan_to_datespan(s._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TstzspansetToDatespanset wraps MEOS C function tstzspanset_to_datespanset. -func TstzspansetToDatespanset(ss *SpanSet) *SpanSet { +func TstzspansetToDatespanset(ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.tstzspanset_to_datespanset(ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // BigintsetEndValue wraps MEOS C function bigintset_end_value. -func BigintsetEndValue(s *Set) int64 { +func BigintsetEndValue(s *Set) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.bigintset_end_value(s._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // BigintsetStartValue wraps MEOS C function bigintset_start_value. -func BigintsetStartValue(s *Set) int64 { +func BigintsetStartValue(s *Set) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.bigintset_start_value(s._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // BigintsetValueN wraps MEOS C function bigintset_value_n. -func BigintsetValueN(s *Set, n int) (bool, int64) { +func BigintsetValueN(s *Set, n int) (_r0 bool, _r1 int64, _err error) { var _out_result C.int64_t + C.meos_errno_reset() _cret := C.bigintset_value_n(s._inner, C.int(n), &_out_result) - return bool(_cret), int64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), int64(_out_result), nil } // BigintsetValues wraps MEOS C function bigintset_values. -func BigintsetValues(s *Set, count unsafe.Pointer) unsafe.Pointer { +func BigintsetValues(s *Set, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.bigintset_values(s._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // BigintspanLower wraps MEOS C function bigintspan_lower. -func BigintspanLower(s *Span) int64 { +func BigintspanLower(s *Span) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.bigintspan_lower(s._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // BigintspanUpper wraps MEOS C function bigintspan_upper. -func BigintspanUpper(s *Span) int64 { +func BigintspanUpper(s *Span) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.bigintspan_upper(s._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // BigintspanWidth wraps MEOS C function bigintspan_width. -func BigintspanWidth(s *Span) int64 { +func BigintspanWidth(s *Span) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.bigintspan_width(s._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // BigintspansetLower wraps MEOS C function bigintspanset_lower. -func BigintspansetLower(ss *SpanSet) int64 { +func BigintspansetLower(ss *SpanSet) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.bigintspanset_lower(ss._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // BigintspansetUpper wraps MEOS C function bigintspanset_upper. -func BigintspansetUpper(ss *SpanSet) int64 { +func BigintspansetUpper(ss *SpanSet) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.bigintspanset_upper(ss._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // BigintspansetWidth wraps MEOS C function bigintspanset_width. -func BigintspansetWidth(ss *SpanSet, boundspan bool) int64 { +func BigintspansetWidth(ss *SpanSet, boundspan bool) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.bigintspanset_width(ss._inner, C.bool(boundspan)) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // DatesetEndValue wraps MEOS C function dateset_end_value. -func DatesetEndValue(s *Set) int32 { +func DatesetEndValue(s *Set) (_r0 int32, _err error) { + C.meos_errno_reset() _cret := C.dateset_end_value(s._inner) - return int32(_cret) + if _err = meosError(); _err != nil { + return + } + return int32(_cret), nil } // DatesetStartValue wraps MEOS C function dateset_start_value. -func DatesetStartValue(s *Set) int32 { +func DatesetStartValue(s *Set) (_r0 int32, _err error) { + C.meos_errno_reset() _cret := C.dateset_start_value(s._inner) - return int32(_cret) + if _err = meosError(); _err != nil { + return + } + return int32(_cret), nil } // DatesetValueN wraps MEOS C function dateset_value_n. -func DatesetValueN(s *Set, n int) (bool, int32) { +func DatesetValueN(s *Set, n int) (_r0 bool, _r1 int32, _err error) { var _out_result C.DateADT + C.meos_errno_reset() _cret := C.dateset_value_n(s._inner, C.int(n), &_out_result) - return bool(_cret), int32(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), int32(_out_result), nil } // DatesetValues wraps MEOS C function dateset_values. -func DatesetValues(s *Set, count unsafe.Pointer) unsafe.Pointer { +func DatesetValues(s *Set, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.dateset_values(s._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // DatespanDuration wraps MEOS C function datespan_duration. -func DatespanDuration(s *Span) *Interval { +func DatespanDuration(s *Span) (_r0 *Interval, _err error) { + C.meos_errno_reset() _cret := C.datespan_duration(s._inner) - return &Interval{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Interval{_inner: _cret}, nil } // DatespanLower wraps MEOS C function datespan_lower. -func DatespanLower(s *Span) int32 { +func DatespanLower(s *Span) (_r0 int32, _err error) { + C.meos_errno_reset() _cret := C.datespan_lower(s._inner) - return int32(_cret) + if _err = meosError(); _err != nil { + return + } + return int32(_cret), nil } // DatespanUpper wraps MEOS C function datespan_upper. -func DatespanUpper(s *Span) int32 { +func DatespanUpper(s *Span) (_r0 int32, _err error) { + C.meos_errno_reset() _cret := C.datespan_upper(s._inner) - return int32(_cret) + if _err = meosError(); _err != nil { + return + } + return int32(_cret), nil } // DatespansetDateN wraps MEOS C function datespanset_date_n. -func DatespansetDateN(ss *SpanSet, n int) (bool, int32) { +func DatespansetDateN(ss *SpanSet, n int) (_r0 bool, _r1 int32, _err error) { var _out_result C.DateADT + C.meos_errno_reset() _cret := C.datespanset_date_n(ss._inner, C.int(n), &_out_result) - return bool(_cret), int32(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), int32(_out_result), nil } // DatespansetDates wraps MEOS C function datespanset_dates. -func DatespansetDates(ss *SpanSet) *Set { +func DatespansetDates(ss *SpanSet) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.datespanset_dates(ss._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // DatespansetDuration wraps MEOS C function datespanset_duration. -func DatespansetDuration(ss *SpanSet, boundspan bool) *Interval { +func DatespansetDuration(ss *SpanSet, boundspan bool) (_r0 *Interval, _err error) { + C.meos_errno_reset() _cret := C.datespanset_duration(ss._inner, C.bool(boundspan)) - return &Interval{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Interval{_inner: _cret}, nil } // DatespansetEndDate wraps MEOS C function datespanset_end_date. -func DatespansetEndDate(ss *SpanSet) int32 { +func DatespansetEndDate(ss *SpanSet) (_r0 int32, _err error) { + C.meos_errno_reset() _cret := C.datespanset_end_date(ss._inner) - return int32(_cret) + if _err = meosError(); _err != nil { + return + } + return int32(_cret), nil } // DatespansetLower wraps MEOS C function datespanset_lower. -func DatespansetLower(ss *SpanSet) int32 { +func DatespansetLower(ss *SpanSet) (_r0 int32, _err error) { + C.meos_errno_reset() _cret := C.datespanset_lower(ss._inner) - return int32(_cret) + if _err = meosError(); _err != nil { + return + } + return int32(_cret), nil } // DatespansetNumDates wraps MEOS C function datespanset_num_dates. -func DatespansetNumDates(ss *SpanSet) int { +func DatespansetNumDates(ss *SpanSet) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.datespanset_num_dates(ss._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // DatespansetStartDate wraps MEOS C function datespanset_start_date. -func DatespansetStartDate(ss *SpanSet) int32 { +func DatespansetStartDate(ss *SpanSet) (_r0 int32, _err error) { + C.meos_errno_reset() _cret := C.datespanset_start_date(ss._inner) - return int32(_cret) + if _err = meosError(); _err != nil { + return + } + return int32(_cret), nil } // DatespansetUpper wraps MEOS C function datespanset_upper. -func DatespansetUpper(ss *SpanSet) int32 { +func DatespansetUpper(ss *SpanSet) (_r0 int32, _err error) { + C.meos_errno_reset() _cret := C.datespanset_upper(ss._inner) - return int32(_cret) + if _err = meosError(); _err != nil { + return + } + return int32(_cret), nil } // FloatsetEndValue wraps MEOS C function floatset_end_value. -func FloatsetEndValue(s *Set) float64 { +func FloatsetEndValue(s *Set) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.floatset_end_value(s._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // FloatsetStartValue wraps MEOS C function floatset_start_value. -func FloatsetStartValue(s *Set) float64 { +func FloatsetStartValue(s *Set) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.floatset_start_value(s._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // FloatsetValueN wraps MEOS C function floatset_value_n. -func FloatsetValueN(s *Set, n int) (bool, float64) { +func FloatsetValueN(s *Set, n int) (_r0 bool, _r1 float64, _err error) { var _out_result C.double + C.meos_errno_reset() _cret := C.floatset_value_n(s._inner, C.int(n), &_out_result) - return bool(_cret), float64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), float64(_out_result), nil } // FloatsetValues wraps MEOS C function floatset_values. -func FloatsetValues(s *Set, count unsafe.Pointer) unsafe.Pointer { +func FloatsetValues(s *Set, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.floatset_values(s._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // FloatspanLower wraps MEOS C function floatspan_lower. -func FloatspanLower(s *Span) float64 { +func FloatspanLower(s *Span) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.floatspan_lower(s._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // FloatspanUpper wraps MEOS C function floatspan_upper. -func FloatspanUpper(s *Span) float64 { +func FloatspanUpper(s *Span) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.floatspan_upper(s._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // FloatspanWidth wraps MEOS C function floatspan_width. -func FloatspanWidth(s *Span) float64 { +func FloatspanWidth(s *Span) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.floatspan_width(s._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // FloatspansetLower wraps MEOS C function floatspanset_lower. -func FloatspansetLower(ss *SpanSet) float64 { +func FloatspansetLower(ss *SpanSet) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.floatspanset_lower(ss._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // FloatspansetUpper wraps MEOS C function floatspanset_upper. -func FloatspansetUpper(ss *SpanSet) float64 { +func FloatspansetUpper(ss *SpanSet) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.floatspanset_upper(ss._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // FloatspansetWidth wraps MEOS C function floatspanset_width. -func FloatspansetWidth(ss *SpanSet, boundspan bool) float64 { +func FloatspansetWidth(ss *SpanSet, boundspan bool) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.floatspanset_width(ss._inner, C.bool(boundspan)) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // IntsetEndValue wraps MEOS C function intset_end_value. -func IntsetEndValue(s *Set) int { +func IntsetEndValue(s *Set) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.intset_end_value(s._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // IntsetStartValue wraps MEOS C function intset_start_value. -func IntsetStartValue(s *Set) int { +func IntsetStartValue(s *Set) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.intset_start_value(s._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // IntsetValueN wraps MEOS C function intset_value_n. -func IntsetValueN(s *Set, n int) (bool, int) { +func IntsetValueN(s *Set, n int) (_r0 bool, _r1 int, _err error) { var _out_result C.int + C.meos_errno_reset() _cret := C.intset_value_n(s._inner, C.int(n), &_out_result) - return bool(_cret), int(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), int(_out_result), nil } // IntsetValues wraps MEOS C function intset_values. -func IntsetValues(s *Set, count unsafe.Pointer) unsafe.Pointer { +func IntsetValues(s *Set, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.intset_values(s._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // IntspanLower wraps MEOS C function intspan_lower. -func IntspanLower(s *Span) int { +func IntspanLower(s *Span) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.intspan_lower(s._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // IntspanUpper wraps MEOS C function intspan_upper. -func IntspanUpper(s *Span) int { +func IntspanUpper(s *Span) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.intspan_upper(s._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // IntspanWidth wraps MEOS C function intspan_width. -func IntspanWidth(s *Span) int { +func IntspanWidth(s *Span) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.intspan_width(s._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // IntspansetLower wraps MEOS C function intspanset_lower. -func IntspansetLower(ss *SpanSet) int { +func IntspansetLower(ss *SpanSet) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.intspanset_lower(ss._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // IntspansetUpper wraps MEOS C function intspanset_upper. -func IntspansetUpper(ss *SpanSet) int { +func IntspansetUpper(ss *SpanSet) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.intspanset_upper(ss._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // IntspansetWidth wraps MEOS C function intspanset_width. -func IntspansetWidth(ss *SpanSet, boundspan bool) int { +func IntspansetWidth(ss *SpanSet, boundspan bool) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.intspanset_width(ss._inner, C.bool(boundspan)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // SetHash wraps MEOS C function set_hash. -func SetHash(s *Set) uint32 { +func SetHash(s *Set) (_r0 uint32, _err error) { + C.meos_errno_reset() _cret := C.set_hash(s._inner) - return uint32(_cret) + if _err = meosError(); _err != nil { + return + } + return uint32(_cret), nil } // SetHashExtended wraps MEOS C function set_hash_extended. -func SetHashExtended(s *Set, seed uint64) uint64 { +func SetHashExtended(s *Set, seed uint64) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.set_hash_extended(s._inner, C.uint64_t(seed)) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // SetNumValues wraps MEOS C function set_num_values. -func SetNumValues(s *Set) int { +func SetNumValues(s *Set) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.set_num_values(s._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // SpanHash wraps MEOS C function span_hash. -func SpanHash(s *Span) uint32 { +func SpanHash(s *Span) (_r0 uint32, _err error) { + C.meos_errno_reset() _cret := C.span_hash(s._inner) - return uint32(_cret) + if _err = meosError(); _err != nil { + return + } + return uint32(_cret), nil } // SpanHashExtended wraps MEOS C function span_hash_extended. -func SpanHashExtended(s *Span, seed uint64) uint64 { +func SpanHashExtended(s *Span, seed uint64) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.span_hash_extended(s._inner, C.uint64_t(seed)) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // SpanLowerInc wraps MEOS C function span_lower_inc. -func SpanLowerInc(s *Span) bool { +func SpanLowerInc(s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.span_lower_inc(s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SpanUpperInc wraps MEOS C function span_upper_inc. -func SpanUpperInc(s *Span) bool { +func SpanUpperInc(s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.span_upper_inc(s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SpansetEndSpan wraps MEOS C function spanset_end_span. -func SpansetEndSpan(ss *SpanSet) *Span { +func SpansetEndSpan(ss *SpanSet) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.spanset_end_span(ss._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // SpansetHash wraps MEOS C function spanset_hash. -func SpansetHash(ss *SpanSet) uint32 { +func SpansetHash(ss *SpanSet) (_r0 uint32, _err error) { + C.meos_errno_reset() _cret := C.spanset_hash(ss._inner) - return uint32(_cret) + if _err = meosError(); _err != nil { + return + } + return uint32(_cret), nil } // SpansetHashExtended wraps MEOS C function spanset_hash_extended. -func SpansetHashExtended(ss *SpanSet, seed uint64) uint64 { +func SpansetHashExtended(ss *SpanSet, seed uint64) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.spanset_hash_extended(ss._inner, C.uint64_t(seed)) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // SpansetLowerInc wraps MEOS C function spanset_lower_inc. -func SpansetLowerInc(ss *SpanSet) bool { +func SpansetLowerInc(ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.spanset_lower_inc(ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SpansetNumSpans wraps MEOS C function spanset_num_spans. -func SpansetNumSpans(ss *SpanSet) int { +func SpansetNumSpans(ss *SpanSet) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.spanset_num_spans(ss._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // SpansetSpan wraps MEOS C function spanset_span. -func SpansetSpan(ss *SpanSet) *Span { +func SpansetSpan(ss *SpanSet) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.spanset_span(ss._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // SpansetSpanN wraps MEOS C function spanset_span_n. -func SpansetSpanN(ss *SpanSet, i int) *Span { +func SpansetSpanN(ss *SpanSet, i int) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.spanset_span_n(ss._inner, C.int(i)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // SpansetSpanarr wraps MEOS C function spanset_spanarr. -func SpansetSpanarr(ss *SpanSet, count unsafe.Pointer) unsafe.Pointer { +func SpansetSpanarr(ss *SpanSet, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.spanset_spanarr(ss._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // SpansetStartSpan wraps MEOS C function spanset_start_span. -func SpansetStartSpan(ss *SpanSet) *Span { +func SpansetStartSpan(ss *SpanSet) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.spanset_start_span(ss._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // SpansetUpperInc wraps MEOS C function spanset_upper_inc. -func SpansetUpperInc(ss *SpanSet) bool { +func SpansetUpperInc(ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.spanset_upper_inc(ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TextsetEndValue wraps MEOS C function textset_end_value. -func TextsetEndValue(s *Set) string { +func TextsetEndValue(s *Set) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.textset_end_value(s._inner) - return C.GoString(C.text_to_cstring(_cret)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(C.text_to_cstring(_cret)), nil } // TextsetStartValue wraps MEOS C function textset_start_value. -func TextsetStartValue(s *Set) string { +func TextsetStartValue(s *Set) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.textset_start_value(s._inner) - return C.GoString(C.text_to_cstring(_cret)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(C.text_to_cstring(_cret)), nil } // TextsetValueN wraps MEOS C function textset_value_n. -func TextsetValueN(s *Set, n int) (bool, string) { +func TextsetValueN(s *Set, n int) (_r0 bool, _r1 string, _err error) { var _out_result *C.text + C.meos_errno_reset() _cret := C.textset_value_n(s._inner, C.int(n), &_out_result) - return bool(_cret), C.GoString(C.text_to_cstring(_out_result)) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), C.GoString(C.text_to_cstring(_out_result)), nil } // TextsetValues wraps MEOS C function textset_values. -func TextsetValues(s *Set, count unsafe.Pointer) unsafe.Pointer { +func TextsetValues(s *Set, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.textset_values(s._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TstzsetEndValue wraps MEOS C function tstzset_end_value. -func TstzsetEndValue(s *Set) int64 { +func TstzsetEndValue(s *Set) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.tstzset_end_value(s._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // TstzsetStartValue wraps MEOS C function tstzset_start_value. -func TstzsetStartValue(s *Set) int64 { +func TstzsetStartValue(s *Set) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.tstzset_start_value(s._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // TstzsetValueN wraps MEOS C function tstzset_value_n. -func TstzsetValueN(s *Set, n int) (bool, int64) { +func TstzsetValueN(s *Set, n int) (_r0 bool, _r1 int64, _err error) { var _out_result C.TimestampTz + C.meos_errno_reset() _cret := C.tstzset_value_n(s._inner, C.int(n), &_out_result) - return bool(_cret), int64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), int64(_out_result), nil } // TstzsetValues wraps MEOS C function tstzset_values. -func TstzsetValues(s *Set, count unsafe.Pointer) unsafe.Pointer { +func TstzsetValues(s *Set, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tstzset_values(s._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TstzspanDuration wraps MEOS C function tstzspan_duration. -func TstzspanDuration(s *Span) *Interval { +func TstzspanDuration(s *Span) (_r0 *Interval, _err error) { + C.meos_errno_reset() _cret := C.tstzspan_duration(s._inner) - return &Interval{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Interval{_inner: _cret}, nil } // TstzspanLower wraps MEOS C function tstzspan_lower. -func TstzspanLower(s *Span) int64 { +func TstzspanLower(s *Span) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.tstzspan_lower(s._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // TstzspanUpper wraps MEOS C function tstzspan_upper. -func TstzspanUpper(s *Span) int64 { +func TstzspanUpper(s *Span) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.tstzspan_upper(s._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // TstzspansetDuration wraps MEOS C function tstzspanset_duration. -func TstzspansetDuration(ss *SpanSet, boundspan bool) *Interval { +func TstzspansetDuration(ss *SpanSet, boundspan bool) (_r0 *Interval, _err error) { + C.meos_errno_reset() _cret := C.tstzspanset_duration(ss._inner, C.bool(boundspan)) - return &Interval{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Interval{_inner: _cret}, nil } // TstzspansetEndTimestamptz wraps MEOS C function tstzspanset_end_timestamptz. -func TstzspansetEndTimestamptz(ss *SpanSet) int64 { +func TstzspansetEndTimestamptz(ss *SpanSet) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.tstzspanset_end_timestamptz(ss._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // TstzspansetLower wraps MEOS C function tstzspanset_lower. -func TstzspansetLower(ss *SpanSet) int64 { +func TstzspansetLower(ss *SpanSet) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.tstzspanset_lower(ss._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // TstzspansetNumTimestamps wraps MEOS C function tstzspanset_num_timestamps. -func TstzspansetNumTimestamps(ss *SpanSet) int { +func TstzspansetNumTimestamps(ss *SpanSet) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.tstzspanset_num_timestamps(ss._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TstzspansetStartTimestamptz wraps MEOS C function tstzspanset_start_timestamptz. -func TstzspansetStartTimestamptz(ss *SpanSet) int64 { +func TstzspansetStartTimestamptz(ss *SpanSet) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.tstzspanset_start_timestamptz(ss._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // TstzspansetTimestamps wraps MEOS C function tstzspanset_timestamps. -func TstzspansetTimestamps(ss *SpanSet) *Set { +func TstzspansetTimestamps(ss *SpanSet) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.tstzspanset_timestamps(ss._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TstzspansetTimestamptzN wraps MEOS C function tstzspanset_timestamptz_n. -func TstzspansetTimestamptzN(ss *SpanSet, n int) (bool, int64) { +func TstzspansetTimestamptzN(ss *SpanSet, n int) (_r0 bool, _r1 int64, _err error) { var _out_result C.TimestampTz + C.meos_errno_reset() _cret := C.tstzspanset_timestamptz_n(ss._inner, C.int(n), &_out_result) - return bool(_cret), int64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), int64(_out_result), nil } // TstzspansetUpper wraps MEOS C function tstzspanset_upper. -func TstzspansetUpper(ss *SpanSet) int64 { +func TstzspansetUpper(ss *SpanSet) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.tstzspanset_upper(ss._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // BigintsetShiftScale wraps MEOS C function bigintset_shift_scale. -func BigintsetShiftScale(s *Set, shift int64, width int64, hasshift bool, haswidth bool) *Set { +func BigintsetShiftScale(s *Set, shift int64, width int64, hasshift bool, haswidth bool) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.bigintset_shift_scale(s._inner, C.int64_t(shift), C.int64_t(width), C.bool(hasshift), C.bool(haswidth)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // BigintspanShiftScale wraps MEOS C function bigintspan_shift_scale. -func BigintspanShiftScale(s *Span, shift int64, width int64, hasshift bool, haswidth bool) *Span { +func BigintspanShiftScale(s *Span, shift int64, width int64, hasshift bool, haswidth bool) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.bigintspan_shift_scale(s._inner, C.int64_t(shift), C.int64_t(width), C.bool(hasshift), C.bool(haswidth)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // BigintspansetShiftScale wraps MEOS C function bigintspanset_shift_scale. -func BigintspansetShiftScale(ss *SpanSet, shift int64, width int64, hasshift bool, haswidth bool) *SpanSet { +func BigintspansetShiftScale(ss *SpanSet, shift int64, width int64, hasshift bool, haswidth bool) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.bigintspanset_shift_scale(ss._inner, C.int64_t(shift), C.int64_t(width), C.bool(hasshift), C.bool(haswidth)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // DatesetShiftScale wraps MEOS C function dateset_shift_scale. -func DatesetShiftScale(s *Set, shift int, width int, hasshift bool, haswidth bool) *Set { +func DatesetShiftScale(s *Set, shift int, width int, hasshift bool, haswidth bool) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.dateset_shift_scale(s._inner, C.int(shift), C.int(width), C.bool(hasshift), C.bool(haswidth)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // DatespanShiftScale wraps MEOS C function datespan_shift_scale. -func DatespanShiftScale(s *Span, shift int, width int, hasshift bool, haswidth bool) *Span { +func DatespanShiftScale(s *Span, shift int, width int, hasshift bool, haswidth bool) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.datespan_shift_scale(s._inner, C.int(shift), C.int(width), C.bool(hasshift), C.bool(haswidth)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // DatespansetShiftScale wraps MEOS C function datespanset_shift_scale. -func DatespansetShiftScale(ss *SpanSet, shift int, width int, hasshift bool, haswidth bool) *SpanSet { +func DatespansetShiftScale(ss *SpanSet, shift int, width int, hasshift bool, haswidth bool) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.datespanset_shift_scale(ss._inner, C.int(shift), C.int(width), C.bool(hasshift), C.bool(haswidth)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // FloatsetCeil wraps MEOS C function floatset_ceil. -func FloatsetCeil(s *Set) *Set { +func FloatsetCeil(s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.floatset_ceil(s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // FloatsetDegrees wraps MEOS C function floatset_degrees. -func FloatsetDegrees(s *Set, normalize bool) *Set { +func FloatsetDegrees(s *Set, normalize bool) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.floatset_degrees(s._inner, C.bool(normalize)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // FloatsetFloor wraps MEOS C function floatset_floor. -func FloatsetFloor(s *Set) *Set { +func FloatsetFloor(s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.floatset_floor(s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // FloatsetRadians wraps MEOS C function floatset_radians. -func FloatsetRadians(s *Set) *Set { +func FloatsetRadians(s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.floatset_radians(s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // FloatsetShiftScale wraps MEOS C function floatset_shift_scale. -func FloatsetShiftScale(s *Set, shift float64, width float64, hasshift bool, haswidth bool) *Set { +func FloatsetShiftScale(s *Set, shift float64, width float64, hasshift bool, haswidth bool) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.floatset_shift_scale(s._inner, C.double(shift), C.double(width), C.bool(hasshift), C.bool(haswidth)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // FloatspanCeil wraps MEOS C function floatspan_ceil. -func FloatspanCeil(s *Span) *Span { +func FloatspanCeil(s *Span) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.floatspan_ceil(s._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // FloatspanDegrees wraps MEOS C function floatspan_degrees. -func FloatspanDegrees(s *Span, normalize bool) *Span { +func FloatspanDegrees(s *Span, normalize bool) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.floatspan_degrees(s._inner, C.bool(normalize)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // FloatspanFloor wraps MEOS C function floatspan_floor. -func FloatspanFloor(s *Span) *Span { +func FloatspanFloor(s *Span) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.floatspan_floor(s._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // FloatspanRadians wraps MEOS C function floatspan_radians. -func FloatspanRadians(s *Span) *Span { +func FloatspanRadians(s *Span) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.floatspan_radians(s._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // FloatspanRound wraps MEOS C function floatspan_round. -func FloatspanRound(s *Span, maxdd int) *Span { +func FloatspanRound(s *Span, maxdd int) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.floatspan_round(s._inner, C.int(maxdd)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // FloatspanShiftScale wraps MEOS C function floatspan_shift_scale. -func FloatspanShiftScale(s *Span, shift float64, width float64, hasshift bool, haswidth bool) *Span { +func FloatspanShiftScale(s *Span, shift float64, width float64, hasshift bool, haswidth bool) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.floatspan_shift_scale(s._inner, C.double(shift), C.double(width), C.bool(hasshift), C.bool(haswidth)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // FloatspansetCeil wraps MEOS C function floatspanset_ceil. -func FloatspansetCeil(ss *SpanSet) *SpanSet { +func FloatspansetCeil(ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.floatspanset_ceil(ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // FloatspansetFloor wraps MEOS C function floatspanset_floor. -func FloatspansetFloor(ss *SpanSet) *SpanSet { +func FloatspansetFloor(ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.floatspanset_floor(ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // FloatspansetDegrees wraps MEOS C function floatspanset_degrees. -func FloatspansetDegrees(ss *SpanSet, normalize bool) *SpanSet { +func FloatspansetDegrees(ss *SpanSet, normalize bool) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.floatspanset_degrees(ss._inner, C.bool(normalize)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // FloatspansetRadians wraps MEOS C function floatspanset_radians. -func FloatspansetRadians(ss *SpanSet) *SpanSet { +func FloatspansetRadians(ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.floatspanset_radians(ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // FloatspansetRound wraps MEOS C function floatspanset_round. -func FloatspansetRound(ss *SpanSet, maxdd int) *SpanSet { +func FloatspansetRound(ss *SpanSet, maxdd int) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.floatspanset_round(ss._inner, C.int(maxdd)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // FloatspansetShiftScale wraps MEOS C function floatspanset_shift_scale. -func FloatspansetShiftScale(ss *SpanSet, shift float64, width float64, hasshift bool, haswidth bool) *SpanSet { +func FloatspansetShiftScale(ss *SpanSet, shift float64, width float64, hasshift bool, haswidth bool) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.floatspanset_shift_scale(ss._inner, C.double(shift), C.double(width), C.bool(hasshift), C.bool(haswidth)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // IntsetShiftScale wraps MEOS C function intset_shift_scale. -func IntsetShiftScale(s *Set, shift int, width int, hasshift bool, haswidth bool) *Set { +func IntsetShiftScale(s *Set, shift int, width int, hasshift bool, haswidth bool) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intset_shift_scale(s._inner, C.int(shift), C.int(width), C.bool(hasshift), C.bool(haswidth)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntspanShiftScale wraps MEOS C function intspan_shift_scale. -func IntspanShiftScale(s *Span, shift int, width int, hasshift bool, haswidth bool) *Span { +func IntspanShiftScale(s *Span, shift int, width int, hasshift bool, haswidth bool) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.intspan_shift_scale(s._inner, C.int(shift), C.int(width), C.bool(hasshift), C.bool(haswidth)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // IntspansetShiftScale wraps MEOS C function intspanset_shift_scale. -func IntspansetShiftScale(ss *SpanSet, shift int, width int, hasshift bool, haswidth bool) *SpanSet { +func IntspansetShiftScale(ss *SpanSet, shift int, width int, hasshift bool, haswidth bool) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.intspanset_shift_scale(ss._inner, C.int(shift), C.int(width), C.bool(hasshift), C.bool(haswidth)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // TstzspanExpand wraps MEOS C function tstzspan_expand. -func TstzspanExpand(s *Span, interv *Interval) *Span { +func TstzspanExpand(s *Span, interv *Interval) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.tstzspan_expand(s._inner, interv._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // SetRound wraps MEOS C function set_round. -func SetRound(s *Set, maxdd int) *Set { +func SetRound(s *Set, maxdd int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.set_round(s._inner, C.int(maxdd)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TextcatTextTextset wraps MEOS C function textcat_text_textset. -func TextcatTextTextset(txt string, s *Set) *Set { +func TextcatTextTextset(txt string, s *Set) (_r0 *Set, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.textcat_text_textset(_c_txt, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TextcatTextsetText wraps MEOS C function textcat_textset_text. -func TextcatTextsetText(s *Set, txt string) *Set { +func TextcatTextsetText(s *Set, txt string) (_r0 *Set, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.textcat_textset_text(s._inner, _c_txt) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TextsetInitcap wraps MEOS C function textset_initcap. -func TextsetInitcap(s *Set) *Set { +func TextsetInitcap(s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.textset_initcap(s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TextsetLower wraps MEOS C function textset_lower. -func TextsetLower(s *Set) *Set { +func TextsetLower(s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.textset_lower(s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TextsetUpper wraps MEOS C function textset_upper. -func TextsetUpper(s *Set) *Set { +func TextsetUpper(s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.textset_upper(s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TimestamptzTprecision wraps MEOS C function timestamptz_tprecision. -func TimestamptzTprecision(t int64, duration *Interval, torigin int64) int64 { +func TimestamptzTprecision(t int64, duration *Interval, torigin int64) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.timestamptz_tprecision(C.TimestampTz(t), duration._inner, C.TimestampTz(torigin)) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // TstzsetShiftScale wraps MEOS C function tstzset_shift_scale. -func TstzsetShiftScale(s *Set, shift *Interval, duration *Interval) *Set { +func TstzsetShiftScale(s *Set, shift *Interval, duration *Interval) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.tstzset_shift_scale(s._inner, shift._inner, duration._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TstzsetTprecision wraps MEOS C function tstzset_tprecision. -func TstzsetTprecision(s *Set, duration *Interval, torigin int64) *Set { +func TstzsetTprecision(s *Set, duration *Interval, torigin int64) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.tstzset_tprecision(s._inner, duration._inner, C.TimestampTz(torigin)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TstzspanShiftScale wraps MEOS C function tstzspan_shift_scale. -func TstzspanShiftScale(s *Span, shift *Interval, duration *Interval) *Span { +func TstzspanShiftScale(s *Span, shift *Interval, duration *Interval) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.tstzspan_shift_scale(s._inner, shift._inner, duration._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TstzspanTprecision wraps MEOS C function tstzspan_tprecision. -func TstzspanTprecision(s *Span, duration *Interval, torigin int64) *Span { +func TstzspanTprecision(s *Span, duration *Interval, torigin int64) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.tstzspan_tprecision(s._inner, duration._inner, C.TimestampTz(torigin)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TstzspansetShiftScale wraps MEOS C function tstzspanset_shift_scale. -func TstzspansetShiftScale(ss *SpanSet, shift *Interval, duration *Interval) *SpanSet { +func TstzspansetShiftScale(ss *SpanSet, shift *Interval, duration *Interval) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.tstzspanset_shift_scale(ss._inner, shift._inner, duration._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // TstzspansetTprecision wraps MEOS C function tstzspanset_tprecision. -func TstzspansetTprecision(ss *SpanSet, duration *Interval, torigin int64) *SpanSet { +func TstzspansetTprecision(ss *SpanSet, duration *Interval, torigin int64) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.tstzspanset_tprecision(ss._inner, duration._inner, C.TimestampTz(torigin)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // SetCmp wraps MEOS C function set_cmp. -func SetCmp(s1 *Set, s2 *Set) int { +func SetCmp(s1 *Set, s2 *Set) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.set_cmp(s1._inner, s2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // SetEq wraps MEOS C function set_eq. -func SetEq(s1 *Set, s2 *Set) bool { +func SetEq(s1 *Set, s2 *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.set_eq(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SetGe wraps MEOS C function set_ge. -func SetGe(s1 *Set, s2 *Set) bool { +func SetGe(s1 *Set, s2 *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.set_ge(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SetGt wraps MEOS C function set_gt. -func SetGt(s1 *Set, s2 *Set) bool { +func SetGt(s1 *Set, s2 *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.set_gt(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SetLe wraps MEOS C function set_le. -func SetLe(s1 *Set, s2 *Set) bool { +func SetLe(s1 *Set, s2 *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.set_le(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SetLt wraps MEOS C function set_lt. -func SetLt(s1 *Set, s2 *Set) bool { +func SetLt(s1 *Set, s2 *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.set_lt(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SetNe wraps MEOS C function set_ne. -func SetNe(s1 *Set, s2 *Set) bool { +func SetNe(s1 *Set, s2 *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.set_ne(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SpanCmp wraps MEOS C function span_cmp. -func SpanCmp(s1 *Span, s2 *Span) int { +func SpanCmp(s1 *Span, s2 *Span) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.span_cmp(s1._inner, s2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // SpanEq wraps MEOS C function span_eq. -func SpanEq(s1 *Span, s2 *Span) bool { +func SpanEq(s1 *Span, s2 *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.span_eq(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SpanGe wraps MEOS C function span_ge. -func SpanGe(s1 *Span, s2 *Span) bool { +func SpanGe(s1 *Span, s2 *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.span_ge(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SpanGt wraps MEOS C function span_gt. -func SpanGt(s1 *Span, s2 *Span) bool { +func SpanGt(s1 *Span, s2 *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.span_gt(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SpanLe wraps MEOS C function span_le. -func SpanLe(s1 *Span, s2 *Span) bool { +func SpanLe(s1 *Span, s2 *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.span_le(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SpanLt wraps MEOS C function span_lt. -func SpanLt(s1 *Span, s2 *Span) bool { +func SpanLt(s1 *Span, s2 *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.span_lt(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SpanNe wraps MEOS C function span_ne. -func SpanNe(s1 *Span, s2 *Span) bool { +func SpanNe(s1 *Span, s2 *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.span_ne(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SpansetCmp wraps MEOS C function spanset_cmp. -func SpansetCmp(ss1 *SpanSet, ss2 *SpanSet) int { +func SpansetCmp(ss1 *SpanSet, ss2 *SpanSet) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.spanset_cmp(ss1._inner, ss2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // SpansetEq wraps MEOS C function spanset_eq. -func SpansetEq(ss1 *SpanSet, ss2 *SpanSet) bool { +func SpansetEq(ss1 *SpanSet, ss2 *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.spanset_eq(ss1._inner, ss2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SpansetGe wraps MEOS C function spanset_ge. -func SpansetGe(ss1 *SpanSet, ss2 *SpanSet) bool { +func SpansetGe(ss1 *SpanSet, ss2 *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.spanset_ge(ss1._inner, ss2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SpansetGt wraps MEOS C function spanset_gt. -func SpansetGt(ss1 *SpanSet, ss2 *SpanSet) bool { +func SpansetGt(ss1 *SpanSet, ss2 *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.spanset_gt(ss1._inner, ss2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SpansetLe wraps MEOS C function spanset_le. -func SpansetLe(ss1 *SpanSet, ss2 *SpanSet) bool { +func SpansetLe(ss1 *SpanSet, ss2 *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.spanset_le(ss1._inner, ss2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SpansetLt wraps MEOS C function spanset_lt. -func SpansetLt(ss1 *SpanSet, ss2 *SpanSet) bool { +func SpansetLt(ss1 *SpanSet, ss2 *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.spanset_lt(ss1._inner, ss2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SpansetNe wraps MEOS C function spanset_ne. -func SpansetNe(ss1 *SpanSet, ss2 *SpanSet) bool { +func SpansetNe(ss1 *SpanSet, ss2 *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.spanset_ne(ss1._inner, ss2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SetSpans wraps MEOS C function set_spans. -func SetSpans(s *Set, count unsafe.Pointer) *Span { +func SetSpans(s *Set, count unsafe.Pointer) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.set_spans(s._inner, (*C.int)(unsafe.Pointer(count))) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // SetSplitEachNSpans wraps MEOS C function set_split_each_n_spans. -func SetSplitEachNSpans(s *Set, elems_per_span int, count unsafe.Pointer) *Span { +func SetSplitEachNSpans(s *Set, elems_per_span int, count unsafe.Pointer) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.set_split_each_n_spans(s._inner, C.int(elems_per_span), (*C.int)(unsafe.Pointer(count))) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // SetSplitNSpans wraps MEOS C function set_split_n_spans. -func SetSplitNSpans(s *Set, span_count int, count unsafe.Pointer) *Span { +func SetSplitNSpans(s *Set, span_count int, count unsafe.Pointer) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.set_split_n_spans(s._inner, C.int(span_count), (*C.int)(unsafe.Pointer(count))) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // SpansetSpans wraps MEOS C function spanset_spans. -func SpansetSpans(ss *SpanSet, count unsafe.Pointer) *Span { +func SpansetSpans(ss *SpanSet, count unsafe.Pointer) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.spanset_spans(ss._inner, (*C.int)(unsafe.Pointer(count))) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // SpansetSplitEachNSpans wraps MEOS C function spanset_split_each_n_spans. -func SpansetSplitEachNSpans(ss *SpanSet, elems_per_span int, count unsafe.Pointer) *Span { +func SpansetSplitEachNSpans(ss *SpanSet, elems_per_span int, count unsafe.Pointer) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.spanset_split_each_n_spans(ss._inner, C.int(elems_per_span), (*C.int)(unsafe.Pointer(count))) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // SpansetSplitNSpans wraps MEOS C function spanset_split_n_spans. -func SpansetSplitNSpans(ss *SpanSet, span_count int, count unsafe.Pointer) *Span { +func SpansetSplitNSpans(ss *SpanSet, span_count int, count unsafe.Pointer) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.spanset_split_n_spans(ss._inner, C.int(span_count), (*C.int)(unsafe.Pointer(count))) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // AdjacentSpanBigint wraps MEOS C function adjacent_span_bigint. -func AdjacentSpanBigint(s *Span, i int64) bool { +func AdjacentSpanBigint(s *Span, i int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_span_bigint(s._inner, C.int64_t(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentSpanDate wraps MEOS C function adjacent_span_date. -func AdjacentSpanDate(s *Span, d int32) bool { +func AdjacentSpanDate(s *Span, d int32) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_span_date(s._inner, C.DateADT(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentSpanFloat wraps MEOS C function adjacent_span_float. -func AdjacentSpanFloat(s *Span, d float64) bool { +func AdjacentSpanFloat(s *Span, d float64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_span_float(s._inner, C.double(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentSpanInt wraps MEOS C function adjacent_span_int. -func AdjacentSpanInt(s *Span, i int) bool { +func AdjacentSpanInt(s *Span, i int) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_span_int(s._inner, C.int(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentSpanSpan wraps MEOS C function adjacent_span_span. -func AdjacentSpanSpan(s1 *Span, s2 *Span) bool { +func AdjacentSpanSpan(s1 *Span, s2 *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_span_span(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentSpanSpanset wraps MEOS C function adjacent_span_spanset. -func AdjacentSpanSpanset(s *Span, ss *SpanSet) bool { +func AdjacentSpanSpanset(s *Span, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_span_spanset(s._inner, ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentSpanTimestamptz wraps MEOS C function adjacent_span_timestamptz. -func AdjacentSpanTimestamptz(s *Span, t int64) bool { +func AdjacentSpanTimestamptz(s *Span, t int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_span_timestamptz(s._inner, C.TimestampTz(t)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentBigintSpan wraps MEOS C function adjacent_bigint_span. -func AdjacentBigintSpan(i int64, s *Span) bool { +func AdjacentBigintSpan(i int64, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_bigint_span(C.int64_t(i), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentDateSpan wraps MEOS C function adjacent_date_span. -func AdjacentDateSpan(d int32, s *Span) bool { +func AdjacentDateSpan(d int32, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_date_span(C.DateADT(d), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentFloatSpan wraps MEOS C function adjacent_float_span. -func AdjacentFloatSpan(d float64, s *Span) bool { +func AdjacentFloatSpan(d float64, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_float_span(C.double(d), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentIntSpan wraps MEOS C function adjacent_int_span. -func AdjacentIntSpan(i int, s *Span) bool { +func AdjacentIntSpan(i int, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_int_span(C.int(i), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentTimestamptzSpan wraps MEOS C function adjacent_timestamptz_span. -func AdjacentTimestamptzSpan(t int64, s *Span) bool { +func AdjacentTimestamptzSpan(t int64, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_timestamptz_span(C.TimestampTz(t), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentSpansetBigint wraps MEOS C function adjacent_spanset_bigint. -func AdjacentSpansetBigint(ss *SpanSet, i int64) bool { +func AdjacentSpansetBigint(ss *SpanSet, i int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_spanset_bigint(ss._inner, C.int64_t(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentSpansetDate wraps MEOS C function adjacent_spanset_date. -func AdjacentSpansetDate(ss *SpanSet, d int32) bool { +func AdjacentSpansetDate(ss *SpanSet, d int32) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_spanset_date(ss._inner, C.DateADT(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentSpansetFloat wraps MEOS C function adjacent_spanset_float. -func AdjacentSpansetFloat(ss *SpanSet, d float64) bool { +func AdjacentSpansetFloat(ss *SpanSet, d float64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_spanset_float(ss._inner, C.double(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentSpansetInt wraps MEOS C function adjacent_spanset_int. -func AdjacentSpansetInt(ss *SpanSet, i int) bool { +func AdjacentSpansetInt(ss *SpanSet, i int) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_spanset_int(ss._inner, C.int(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentSpansetTimestamptz wraps MEOS C function adjacent_spanset_timestamptz. -func AdjacentSpansetTimestamptz(ss *SpanSet, t int64) bool { +func AdjacentSpansetTimestamptz(ss *SpanSet, t int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_spanset_timestamptz(ss._inner, C.TimestampTz(t)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentSpansetSpan wraps MEOS C function adjacent_spanset_span. -func AdjacentSpansetSpan(ss *SpanSet, s *Span) bool { +func AdjacentSpansetSpan(ss *SpanSet, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_spanset_span(ss._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentSpansetSpanset wraps MEOS C function adjacent_spanset_spanset. -func AdjacentSpansetSpanset(ss1 *SpanSet, ss2 *SpanSet) bool { +func AdjacentSpansetSpanset(ss1 *SpanSet, ss2 *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_spanset_spanset(ss1._inner, ss2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedBigintSet wraps MEOS C function contained_bigint_set. -func ContainedBigintSet(i int64, s *Set) bool { +func ContainedBigintSet(i int64, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_bigint_set(C.int64_t(i), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedBigintSpan wraps MEOS C function contained_bigint_span. -func ContainedBigintSpan(i int64, s *Span) bool { +func ContainedBigintSpan(i int64, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_bigint_span(C.int64_t(i), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedBigintSpanset wraps MEOS C function contained_bigint_spanset. -func ContainedBigintSpanset(i int64, ss *SpanSet) bool { +func ContainedBigintSpanset(i int64, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_bigint_spanset(C.int64_t(i), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedDateSet wraps MEOS C function contained_date_set. -func ContainedDateSet(d int32, s *Set) bool { +func ContainedDateSet(d int32, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_date_set(C.DateADT(d), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedDateSpan wraps MEOS C function contained_date_span. -func ContainedDateSpan(d int32, s *Span) bool { +func ContainedDateSpan(d int32, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_date_span(C.DateADT(d), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedDateSpanset wraps MEOS C function contained_date_spanset. -func ContainedDateSpanset(d int32, ss *SpanSet) bool { +func ContainedDateSpanset(d int32, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_date_spanset(C.DateADT(d), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedFloatSet wraps MEOS C function contained_float_set. -func ContainedFloatSet(d float64, s *Set) bool { +func ContainedFloatSet(d float64, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_float_set(C.double(d), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedFloatSpan wraps MEOS C function contained_float_span. -func ContainedFloatSpan(d float64, s *Span) bool { +func ContainedFloatSpan(d float64, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_float_span(C.double(d), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedFloatSpanset wraps MEOS C function contained_float_spanset. -func ContainedFloatSpanset(d float64, ss *SpanSet) bool { +func ContainedFloatSpanset(d float64, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_float_spanset(C.double(d), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedIntSet wraps MEOS C function contained_int_set. -func ContainedIntSet(i int, s *Set) bool { +func ContainedIntSet(i int, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_int_set(C.int(i), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedIntSpan wraps MEOS C function contained_int_span. -func ContainedIntSpan(i int, s *Span) bool { +func ContainedIntSpan(i int, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_int_span(C.int(i), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedIntSpanset wraps MEOS C function contained_int_spanset. -func ContainedIntSpanset(i int, ss *SpanSet) bool { +func ContainedIntSpanset(i int, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_int_spanset(C.int(i), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedSetSet wraps MEOS C function contained_set_set. -func ContainedSetSet(s1 *Set, s2 *Set) bool { +func ContainedSetSet(s1 *Set, s2 *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_set_set(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedSpanSpan wraps MEOS C function contained_span_span. -func ContainedSpanSpan(s1 *Span, s2 *Span) bool { +func ContainedSpanSpan(s1 *Span, s2 *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_span_span(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedSpanSpanset wraps MEOS C function contained_span_spanset. -func ContainedSpanSpanset(s *Span, ss *SpanSet) bool { +func ContainedSpanSpanset(s *Span, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_span_spanset(s._inner, ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedSpansetSpan wraps MEOS C function contained_spanset_span. -func ContainedSpansetSpan(ss *SpanSet, s *Span) bool { +func ContainedSpansetSpan(ss *SpanSet, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_spanset_span(ss._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedSpansetSpanset wraps MEOS C function contained_spanset_spanset. -func ContainedSpansetSpanset(ss1 *SpanSet, ss2 *SpanSet) bool { +func ContainedSpansetSpanset(ss1 *SpanSet, ss2 *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_spanset_spanset(ss1._inner, ss2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedTextSet wraps MEOS C function contained_text_set. -func ContainedTextSet(txt string, s *Set) bool { +func ContainedTextSet(txt string, s *Set) (_r0 bool, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.contained_text_set(_c_txt, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedTimestamptzSet wraps MEOS C function contained_timestamptz_set. -func ContainedTimestamptzSet(t int64, s *Set) bool { +func ContainedTimestamptzSet(t int64, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_timestamptz_set(C.TimestampTz(t), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedTimestamptzSpan wraps MEOS C function contained_timestamptz_span. -func ContainedTimestamptzSpan(t int64, s *Span) bool { +func ContainedTimestamptzSpan(t int64, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_timestamptz_span(C.TimestampTz(t), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedTimestamptzSpanset wraps MEOS C function contained_timestamptz_spanset. -func ContainedTimestamptzSpanset(t int64, ss *SpanSet) bool { +func ContainedTimestamptzSpanset(t int64, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_timestamptz_spanset(C.TimestampTz(t), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSetBigint wraps MEOS C function contains_set_bigint. -func ContainsSetBigint(s *Set, i int64) bool { +func ContainsSetBigint(s *Set, i int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_set_bigint(s._inner, C.int64_t(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSetDate wraps MEOS C function contains_set_date. -func ContainsSetDate(s *Set, d int32) bool { +func ContainsSetDate(s *Set, d int32) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_set_date(s._inner, C.DateADT(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSetFloat wraps MEOS C function contains_set_float. -func ContainsSetFloat(s *Set, d float64) bool { +func ContainsSetFloat(s *Set, d float64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_set_float(s._inner, C.double(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSetInt wraps MEOS C function contains_set_int. -func ContainsSetInt(s *Set, i int) bool { +func ContainsSetInt(s *Set, i int) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_set_int(s._inner, C.int(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSetSet wraps MEOS C function contains_set_set. -func ContainsSetSet(s1 *Set, s2 *Set) bool { +func ContainsSetSet(s1 *Set, s2 *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_set_set(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSetText wraps MEOS C function contains_set_text. -func ContainsSetText(s *Set, t string) bool { +func ContainsSetText(s *Set, t string) (_r0 bool, _err error) { _c_t := C.cstring_to_text(C.CString(t)) defer C.free(unsafe.Pointer(_c_t)) + C.meos_errno_reset() _cret := C.contains_set_text(s._inner, _c_t) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSetTimestamptz wraps MEOS C function contains_set_timestamptz. -func ContainsSetTimestamptz(s *Set, t int64) bool { +func ContainsSetTimestamptz(s *Set, t int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_set_timestamptz(s._inner, C.TimestampTz(t)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSpanBigint wraps MEOS C function contains_span_bigint. -func ContainsSpanBigint(s *Span, i int64) bool { +func ContainsSpanBigint(s *Span, i int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_span_bigint(s._inner, C.int64_t(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSpanDate wraps MEOS C function contains_span_date. -func ContainsSpanDate(s *Span, d int32) bool { +func ContainsSpanDate(s *Span, d int32) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_span_date(s._inner, C.DateADT(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSpanFloat wraps MEOS C function contains_span_float. -func ContainsSpanFloat(s *Span, d float64) bool { +func ContainsSpanFloat(s *Span, d float64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_span_float(s._inner, C.double(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSpanInt wraps MEOS C function contains_span_int. -func ContainsSpanInt(s *Span, i int) bool { +func ContainsSpanInt(s *Span, i int) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_span_int(s._inner, C.int(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSpanSpan wraps MEOS C function contains_span_span. -func ContainsSpanSpan(s1 *Span, s2 *Span) bool { +func ContainsSpanSpan(s1 *Span, s2 *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_span_span(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSpanSpanset wraps MEOS C function contains_span_spanset. -func ContainsSpanSpanset(s *Span, ss *SpanSet) bool { +func ContainsSpanSpanset(s *Span, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_span_spanset(s._inner, ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSpanTimestamptz wraps MEOS C function contains_span_timestamptz. -func ContainsSpanTimestamptz(s *Span, t int64) bool { +func ContainsSpanTimestamptz(s *Span, t int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_span_timestamptz(s._inner, C.TimestampTz(t)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSpansetBigint wraps MEOS C function contains_spanset_bigint. -func ContainsSpansetBigint(ss *SpanSet, i int64) bool { +func ContainsSpansetBigint(ss *SpanSet, i int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_spanset_bigint(ss._inner, C.int64_t(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSpansetDate wraps MEOS C function contains_spanset_date. -func ContainsSpansetDate(ss *SpanSet, d int32) bool { +func ContainsSpansetDate(ss *SpanSet, d int32) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_spanset_date(ss._inner, C.DateADT(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSpansetFloat wraps MEOS C function contains_spanset_float. -func ContainsSpansetFloat(ss *SpanSet, d float64) bool { +func ContainsSpansetFloat(ss *SpanSet, d float64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_spanset_float(ss._inner, C.double(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSpansetInt wraps MEOS C function contains_spanset_int. -func ContainsSpansetInt(ss *SpanSet, i int) bool { +func ContainsSpansetInt(ss *SpanSet, i int) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_spanset_int(ss._inner, C.int(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSpansetSpan wraps MEOS C function contains_spanset_span. -func ContainsSpansetSpan(ss *SpanSet, s *Span) bool { +func ContainsSpansetSpan(ss *SpanSet, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_spanset_span(ss._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSpansetSpanset wraps MEOS C function contains_spanset_spanset. -func ContainsSpansetSpanset(ss1 *SpanSet, ss2 *SpanSet) bool { +func ContainsSpansetSpanset(ss1 *SpanSet, ss2 *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_spanset_spanset(ss1._inner, ss2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSpansetTimestamptz wraps MEOS C function contains_spanset_timestamptz. -func ContainsSpansetTimestamptz(ss *SpanSet, t int64) bool { +func ContainsSpansetTimestamptz(ss *SpanSet, t int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_spanset_timestamptz(ss._inner, C.TimestampTz(t)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverlapsSetSet wraps MEOS C function overlaps_set_set. -func OverlapsSetSet(s1 *Set, s2 *Set) bool { +func OverlapsSetSet(s1 *Set, s2 *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overlaps_set_set(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverlapsSpanSpan wraps MEOS C function overlaps_span_span. -func OverlapsSpanSpan(s1 *Span, s2 *Span) bool { +func OverlapsSpanSpan(s1 *Span, s2 *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overlaps_span_span(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverlapsSpanSpanset wraps MEOS C function overlaps_span_spanset. -func OverlapsSpanSpanset(s *Span, ss *SpanSet) bool { +func OverlapsSpanSpanset(s *Span, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overlaps_span_spanset(s._inner, ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverlapsSpansetSpan wraps MEOS C function overlaps_spanset_span. -func OverlapsSpansetSpan(ss *SpanSet, s *Span) bool { +func OverlapsSpansetSpan(ss *SpanSet, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overlaps_spanset_span(ss._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverlapsSpansetSpanset wraps MEOS C function overlaps_spanset_spanset. -func OverlapsSpansetSpanset(ss1 *SpanSet, ss2 *SpanSet) bool { +func OverlapsSpansetSpanset(ss1 *SpanSet, ss2 *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overlaps_spanset_spanset(ss1._inner, ss2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SameSpanSpan wraps MEOS C function same_span_span. -func SameSpanSpan(s1 *Span, s2 *Span) bool { +func SameSpanSpan(s1 *Span, s2 *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.same_span_span(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterDateSet wraps MEOS C function after_date_set. -func AfterDateSet(d int32, s *Set) bool { +func AfterDateSet(d int32, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_date_set(C.DateADT(d), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterDateSpan wraps MEOS C function after_date_span. -func AfterDateSpan(d int32, s *Span) bool { +func AfterDateSpan(d int32, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_date_span(C.DateADT(d), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterDateSpanset wraps MEOS C function after_date_spanset. -func AfterDateSpanset(d int32, ss *SpanSet) bool { +func AfterDateSpanset(d int32, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_date_spanset(C.DateADT(d), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterSetDate wraps MEOS C function after_set_date. -func AfterSetDate(s *Set, d int32) bool { +func AfterSetDate(s *Set, d int32) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_set_date(s._inner, C.DateADT(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterSetTimestamptz wraps MEOS C function after_set_timestamptz. -func AfterSetTimestamptz(s *Set, t int64) bool { +func AfterSetTimestamptz(s *Set, t int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_set_timestamptz(s._inner, C.TimestampTz(t)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterSpanDate wraps MEOS C function after_span_date. -func AfterSpanDate(s *Span, d int32) bool { +func AfterSpanDate(s *Span, d int32) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_span_date(s._inner, C.DateADT(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterSpanTimestamptz wraps MEOS C function after_span_timestamptz. -func AfterSpanTimestamptz(s *Span, t int64) bool { +func AfterSpanTimestamptz(s *Span, t int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_span_timestamptz(s._inner, C.TimestampTz(t)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterSpansetDate wraps MEOS C function after_spanset_date. -func AfterSpansetDate(ss *SpanSet, d int32) bool { +func AfterSpansetDate(ss *SpanSet, d int32) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_spanset_date(ss._inner, C.DateADT(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterSpansetTimestamptz wraps MEOS C function after_spanset_timestamptz. -func AfterSpansetTimestamptz(ss *SpanSet, t int64) bool { +func AfterSpansetTimestamptz(ss *SpanSet, t int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_spanset_timestamptz(ss._inner, C.TimestampTz(t)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterTimestamptzSet wraps MEOS C function after_timestamptz_set. -func AfterTimestamptzSet(t int64, s *Set) bool { +func AfterTimestamptzSet(t int64, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_timestamptz_set(C.TimestampTz(t), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterTimestamptzSpan wraps MEOS C function after_timestamptz_span. -func AfterTimestamptzSpan(t int64, s *Span) bool { +func AfterTimestamptzSpan(t int64, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_timestamptz_span(C.TimestampTz(t), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterTimestamptzSpanset wraps MEOS C function after_timestamptz_spanset. -func AfterTimestamptzSpanset(t int64, ss *SpanSet) bool { +func AfterTimestamptzSpanset(t int64, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_timestamptz_spanset(C.TimestampTz(t), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeDateSet wraps MEOS C function before_date_set. -func BeforeDateSet(d int32, s *Set) bool { +func BeforeDateSet(d int32, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_date_set(C.DateADT(d), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeDateSpan wraps MEOS C function before_date_span. -func BeforeDateSpan(d int32, s *Span) bool { +func BeforeDateSpan(d int32, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_date_span(C.DateADT(d), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeDateSpanset wraps MEOS C function before_date_spanset. -func BeforeDateSpanset(d int32, ss *SpanSet) bool { +func BeforeDateSpanset(d int32, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_date_spanset(C.DateADT(d), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeSetDate wraps MEOS C function before_set_date. -func BeforeSetDate(s *Set, d int32) bool { +func BeforeSetDate(s *Set, d int32) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_set_date(s._inner, C.DateADT(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeSetTimestamptz wraps MEOS C function before_set_timestamptz. -func BeforeSetTimestamptz(s *Set, t int64) bool { +func BeforeSetTimestamptz(s *Set, t int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_set_timestamptz(s._inner, C.TimestampTz(t)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeSpanDate wraps MEOS C function before_span_date. -func BeforeSpanDate(s *Span, d int32) bool { +func BeforeSpanDate(s *Span, d int32) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_span_date(s._inner, C.DateADT(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeSpanTimestamptz wraps MEOS C function before_span_timestamptz. -func BeforeSpanTimestamptz(s *Span, t int64) bool { +func BeforeSpanTimestamptz(s *Span, t int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_span_timestamptz(s._inner, C.TimestampTz(t)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeSpansetDate wraps MEOS C function before_spanset_date. -func BeforeSpansetDate(ss *SpanSet, d int32) bool { +func BeforeSpansetDate(ss *SpanSet, d int32) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_spanset_date(ss._inner, C.DateADT(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeSpansetTimestamptz wraps MEOS C function before_spanset_timestamptz. -func BeforeSpansetTimestamptz(ss *SpanSet, t int64) bool { +func BeforeSpansetTimestamptz(ss *SpanSet, t int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_spanset_timestamptz(ss._inner, C.TimestampTz(t)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeTimestamptzSet wraps MEOS C function before_timestamptz_set. -func BeforeTimestamptzSet(t int64, s *Set) bool { +func BeforeTimestamptzSet(t int64, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_timestamptz_set(C.TimestampTz(t), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeTimestamptzSpan wraps MEOS C function before_timestamptz_span. -func BeforeTimestamptzSpan(t int64, s *Span) bool { +func BeforeTimestamptzSpan(t int64, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_timestamptz_span(C.TimestampTz(t), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeTimestamptzSpanset wraps MEOS C function before_timestamptz_spanset. -func BeforeTimestamptzSpanset(t int64, ss *SpanSet) bool { +func BeforeTimestamptzSpanset(t int64, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_timestamptz_spanset(C.TimestampTz(t), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftBigintSet wraps MEOS C function left_bigint_set. -func LeftBigintSet(i int64, s *Set) bool { +func LeftBigintSet(i int64, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_bigint_set(C.int64_t(i), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftBigintSpan wraps MEOS C function left_bigint_span. -func LeftBigintSpan(i int64, s *Span) bool { +func LeftBigintSpan(i int64, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_bigint_span(C.int64_t(i), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftBigintSpanset wraps MEOS C function left_bigint_spanset. -func LeftBigintSpanset(i int64, ss *SpanSet) bool { +func LeftBigintSpanset(i int64, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_bigint_spanset(C.int64_t(i), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftFloatSet wraps MEOS C function left_float_set. -func LeftFloatSet(d float64, s *Set) bool { +func LeftFloatSet(d float64, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_float_set(C.double(d), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftFloatSpan wraps MEOS C function left_float_span. -func LeftFloatSpan(d float64, s *Span) bool { +func LeftFloatSpan(d float64, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_float_span(C.double(d), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftFloatSpanset wraps MEOS C function left_float_spanset. -func LeftFloatSpanset(d float64, ss *SpanSet) bool { +func LeftFloatSpanset(d float64, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_float_spanset(C.double(d), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftIntSet wraps MEOS C function left_int_set. -func LeftIntSet(i int, s *Set) bool { +func LeftIntSet(i int, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_int_set(C.int(i), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftIntSpan wraps MEOS C function left_int_span. -func LeftIntSpan(i int, s *Span) bool { +func LeftIntSpan(i int, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_int_span(C.int(i), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftIntSpanset wraps MEOS C function left_int_spanset. -func LeftIntSpanset(i int, ss *SpanSet) bool { +func LeftIntSpanset(i int, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_int_spanset(C.int(i), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftSetBigint wraps MEOS C function left_set_bigint. -func LeftSetBigint(s *Set, i int64) bool { +func LeftSetBigint(s *Set, i int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_set_bigint(s._inner, C.int64_t(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftSetFloat wraps MEOS C function left_set_float. -func LeftSetFloat(s *Set, d float64) bool { +func LeftSetFloat(s *Set, d float64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_set_float(s._inner, C.double(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftSetInt wraps MEOS C function left_set_int. -func LeftSetInt(s *Set, i int) bool { +func LeftSetInt(s *Set, i int) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_set_int(s._inner, C.int(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftSetSet wraps MEOS C function left_set_set. -func LeftSetSet(s1 *Set, s2 *Set) bool { +func LeftSetSet(s1 *Set, s2 *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_set_set(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftSetText wraps MEOS C function left_set_text. -func LeftSetText(s *Set, txt string) bool { +func LeftSetText(s *Set, txt string) (_r0 bool, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.left_set_text(s._inner, _c_txt) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftSpanBigint wraps MEOS C function left_span_bigint. -func LeftSpanBigint(s *Span, i int64) bool { +func LeftSpanBigint(s *Span, i int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_span_bigint(s._inner, C.int64_t(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftSpanFloat wraps MEOS C function left_span_float. -func LeftSpanFloat(s *Span, d float64) bool { +func LeftSpanFloat(s *Span, d float64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_span_float(s._inner, C.double(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftSpanInt wraps MEOS C function left_span_int. -func LeftSpanInt(s *Span, i int) bool { +func LeftSpanInt(s *Span, i int) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_span_int(s._inner, C.int(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftSpanSpan wraps MEOS C function left_span_span. -func LeftSpanSpan(s1 *Span, s2 *Span) bool { +func LeftSpanSpan(s1 *Span, s2 *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_span_span(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftSpanSpanset wraps MEOS C function left_span_spanset. -func LeftSpanSpanset(s *Span, ss *SpanSet) bool { +func LeftSpanSpanset(s *Span, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_span_spanset(s._inner, ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftSpansetBigint wraps MEOS C function left_spanset_bigint. -func LeftSpansetBigint(ss *SpanSet, i int64) bool { +func LeftSpansetBigint(ss *SpanSet, i int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_spanset_bigint(ss._inner, C.int64_t(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftSpansetFloat wraps MEOS C function left_spanset_float. -func LeftSpansetFloat(ss *SpanSet, d float64) bool { +func LeftSpansetFloat(ss *SpanSet, d float64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_spanset_float(ss._inner, C.double(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftSpansetInt wraps MEOS C function left_spanset_int. -func LeftSpansetInt(ss *SpanSet, i int) bool { +func LeftSpansetInt(ss *SpanSet, i int) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_spanset_int(ss._inner, C.int(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftSpansetSpan wraps MEOS C function left_spanset_span. -func LeftSpansetSpan(ss *SpanSet, s *Span) bool { +func LeftSpansetSpan(ss *SpanSet, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_spanset_span(ss._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftSpansetSpanset wraps MEOS C function left_spanset_spanset. -func LeftSpansetSpanset(ss1 *SpanSet, ss2 *SpanSet) bool { +func LeftSpansetSpanset(ss1 *SpanSet, ss2 *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_spanset_spanset(ss1._inner, ss2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftTextSet wraps MEOS C function left_text_set. -func LeftTextSet(txt string, s *Set) bool { +func LeftTextSet(txt string, s *Set) (_r0 bool, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.left_text_set(_c_txt, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterDateSet wraps MEOS C function overafter_date_set. -func OverafterDateSet(d int32, s *Set) bool { +func OverafterDateSet(d int32, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_date_set(C.DateADT(d), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterDateSpan wraps MEOS C function overafter_date_span. -func OverafterDateSpan(d int32, s *Span) bool { +func OverafterDateSpan(d int32, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_date_span(C.DateADT(d), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterDateSpanset wraps MEOS C function overafter_date_spanset. -func OverafterDateSpanset(d int32, ss *SpanSet) bool { +func OverafterDateSpanset(d int32, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_date_spanset(C.DateADT(d), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterSetDate wraps MEOS C function overafter_set_date. -func OverafterSetDate(s *Set, d int32) bool { +func OverafterSetDate(s *Set, d int32) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_set_date(s._inner, C.DateADT(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterSetTimestamptz wraps MEOS C function overafter_set_timestamptz. -func OverafterSetTimestamptz(s *Set, t int64) bool { +func OverafterSetTimestamptz(s *Set, t int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_set_timestamptz(s._inner, C.TimestampTz(t)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterSpanDate wraps MEOS C function overafter_span_date. -func OverafterSpanDate(s *Span, d int32) bool { +func OverafterSpanDate(s *Span, d int32) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_span_date(s._inner, C.DateADT(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterSpanTimestamptz wraps MEOS C function overafter_span_timestamptz. -func OverafterSpanTimestamptz(s *Span, t int64) bool { +func OverafterSpanTimestamptz(s *Span, t int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_span_timestamptz(s._inner, C.TimestampTz(t)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterSpansetDate wraps MEOS C function overafter_spanset_date. -func OverafterSpansetDate(ss *SpanSet, d int32) bool { +func OverafterSpansetDate(ss *SpanSet, d int32) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_spanset_date(ss._inner, C.DateADT(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterSpansetTimestamptz wraps MEOS C function overafter_spanset_timestamptz. -func OverafterSpansetTimestamptz(ss *SpanSet, t int64) bool { +func OverafterSpansetTimestamptz(ss *SpanSet, t int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_spanset_timestamptz(ss._inner, C.TimestampTz(t)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterTimestamptzSet wraps MEOS C function overafter_timestamptz_set. -func OverafterTimestamptzSet(t int64, s *Set) bool { +func OverafterTimestamptzSet(t int64, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_timestamptz_set(C.TimestampTz(t), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterTimestamptzSpan wraps MEOS C function overafter_timestamptz_span. -func OverafterTimestamptzSpan(t int64, s *Span) bool { +func OverafterTimestamptzSpan(t int64, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_timestamptz_span(C.TimestampTz(t), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterTimestamptzSpanset wraps MEOS C function overafter_timestamptz_spanset. -func OverafterTimestamptzSpanset(t int64, ss *SpanSet) bool { +func OverafterTimestamptzSpanset(t int64, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_timestamptz_spanset(C.TimestampTz(t), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeDateSet wraps MEOS C function overbefore_date_set. -func OverbeforeDateSet(d int32, s *Set) bool { +func OverbeforeDateSet(d int32, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_date_set(C.DateADT(d), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeDateSpan wraps MEOS C function overbefore_date_span. -func OverbeforeDateSpan(d int32, s *Span) bool { +func OverbeforeDateSpan(d int32, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_date_span(C.DateADT(d), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeDateSpanset wraps MEOS C function overbefore_date_spanset. -func OverbeforeDateSpanset(d int32, ss *SpanSet) bool { +func OverbeforeDateSpanset(d int32, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_date_spanset(C.DateADT(d), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeSetDate wraps MEOS C function overbefore_set_date. -func OverbeforeSetDate(s *Set, d int32) bool { +func OverbeforeSetDate(s *Set, d int32) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_set_date(s._inner, C.DateADT(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeSetTimestamptz wraps MEOS C function overbefore_set_timestamptz. -func OverbeforeSetTimestamptz(s *Set, t int64) bool { +func OverbeforeSetTimestamptz(s *Set, t int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_set_timestamptz(s._inner, C.TimestampTz(t)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeSpanDate wraps MEOS C function overbefore_span_date. -func OverbeforeSpanDate(s *Span, d int32) bool { +func OverbeforeSpanDate(s *Span, d int32) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_span_date(s._inner, C.DateADT(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeSpanTimestamptz wraps MEOS C function overbefore_span_timestamptz. -func OverbeforeSpanTimestamptz(s *Span, t int64) bool { +func OverbeforeSpanTimestamptz(s *Span, t int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_span_timestamptz(s._inner, C.TimestampTz(t)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeSpansetDate wraps MEOS C function overbefore_spanset_date. -func OverbeforeSpansetDate(ss *SpanSet, d int32) bool { +func OverbeforeSpansetDate(ss *SpanSet, d int32) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_spanset_date(ss._inner, C.DateADT(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeSpansetTimestamptz wraps MEOS C function overbefore_spanset_timestamptz. -func OverbeforeSpansetTimestamptz(ss *SpanSet, t int64) bool { +func OverbeforeSpansetTimestamptz(ss *SpanSet, t int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_spanset_timestamptz(ss._inner, C.TimestampTz(t)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeTimestamptzSet wraps MEOS C function overbefore_timestamptz_set. -func OverbeforeTimestamptzSet(t int64, s *Set) bool { +func OverbeforeTimestamptzSet(t int64, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_timestamptz_set(C.TimestampTz(t), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeTimestamptzSpan wraps MEOS C function overbefore_timestamptz_span. -func OverbeforeTimestamptzSpan(t int64, s *Span) bool { +func OverbeforeTimestamptzSpan(t int64, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_timestamptz_span(C.TimestampTz(t), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeTimestamptzSpanset wraps MEOS C function overbefore_timestamptz_spanset. -func OverbeforeTimestamptzSpanset(t int64, ss *SpanSet) bool { +func OverbeforeTimestamptzSpanset(t int64, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_timestamptz_spanset(C.TimestampTz(t), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftBigintSet wraps MEOS C function overleft_bigint_set. -func OverleftBigintSet(i int64, s *Set) bool { +func OverleftBigintSet(i int64, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_bigint_set(C.int64_t(i), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftBigintSpan wraps MEOS C function overleft_bigint_span. -func OverleftBigintSpan(i int64, s *Span) bool { +func OverleftBigintSpan(i int64, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_bigint_span(C.int64_t(i), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftBigintSpanset wraps MEOS C function overleft_bigint_spanset. -func OverleftBigintSpanset(i int64, ss *SpanSet) bool { +func OverleftBigintSpanset(i int64, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_bigint_spanset(C.int64_t(i), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftFloatSet wraps MEOS C function overleft_float_set. -func OverleftFloatSet(d float64, s *Set) bool { +func OverleftFloatSet(d float64, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_float_set(C.double(d), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftFloatSpan wraps MEOS C function overleft_float_span. -func OverleftFloatSpan(d float64, s *Span) bool { +func OverleftFloatSpan(d float64, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_float_span(C.double(d), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftFloatSpanset wraps MEOS C function overleft_float_spanset. -func OverleftFloatSpanset(d float64, ss *SpanSet) bool { +func OverleftFloatSpanset(d float64, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_float_spanset(C.double(d), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftIntSet wraps MEOS C function overleft_int_set. -func OverleftIntSet(i int, s *Set) bool { +func OverleftIntSet(i int, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_int_set(C.int(i), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftIntSpan wraps MEOS C function overleft_int_span. -func OverleftIntSpan(i int, s *Span) bool { +func OverleftIntSpan(i int, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_int_span(C.int(i), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftIntSpanset wraps MEOS C function overleft_int_spanset. -func OverleftIntSpanset(i int, ss *SpanSet) bool { +func OverleftIntSpanset(i int, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_int_spanset(C.int(i), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftSetBigint wraps MEOS C function overleft_set_bigint. -func OverleftSetBigint(s *Set, i int64) bool { +func OverleftSetBigint(s *Set, i int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_set_bigint(s._inner, C.int64_t(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftSetFloat wraps MEOS C function overleft_set_float. -func OverleftSetFloat(s *Set, d float64) bool { +func OverleftSetFloat(s *Set, d float64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_set_float(s._inner, C.double(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftSetInt wraps MEOS C function overleft_set_int. -func OverleftSetInt(s *Set, i int) bool { +func OverleftSetInt(s *Set, i int) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_set_int(s._inner, C.int(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftSetSet wraps MEOS C function overleft_set_set. -func OverleftSetSet(s1 *Set, s2 *Set) bool { +func OverleftSetSet(s1 *Set, s2 *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_set_set(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftSetText wraps MEOS C function overleft_set_text. -func OverleftSetText(s *Set, txt string) bool { +func OverleftSetText(s *Set, txt string) (_r0 bool, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.overleft_set_text(s._inner, _c_txt) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftSpanBigint wraps MEOS C function overleft_span_bigint. -func OverleftSpanBigint(s *Span, i int64) bool { +func OverleftSpanBigint(s *Span, i int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_span_bigint(s._inner, C.int64_t(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftSpanFloat wraps MEOS C function overleft_span_float. -func OverleftSpanFloat(s *Span, d float64) bool { +func OverleftSpanFloat(s *Span, d float64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_span_float(s._inner, C.double(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftSpanInt wraps MEOS C function overleft_span_int. -func OverleftSpanInt(s *Span, i int) bool { +func OverleftSpanInt(s *Span, i int) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_span_int(s._inner, C.int(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftSpanSpan wraps MEOS C function overleft_span_span. -func OverleftSpanSpan(s1 *Span, s2 *Span) bool { +func OverleftSpanSpan(s1 *Span, s2 *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_span_span(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftSpanSpanset wraps MEOS C function overleft_span_spanset. -func OverleftSpanSpanset(s *Span, ss *SpanSet) bool { +func OverleftSpanSpanset(s *Span, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_span_spanset(s._inner, ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftSpansetBigint wraps MEOS C function overleft_spanset_bigint. -func OverleftSpansetBigint(ss *SpanSet, i int64) bool { +func OverleftSpansetBigint(ss *SpanSet, i int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_spanset_bigint(ss._inner, C.int64_t(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftSpansetFloat wraps MEOS C function overleft_spanset_float. -func OverleftSpansetFloat(ss *SpanSet, d float64) bool { +func OverleftSpansetFloat(ss *SpanSet, d float64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_spanset_float(ss._inner, C.double(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftSpansetInt wraps MEOS C function overleft_spanset_int. -func OverleftSpansetInt(ss *SpanSet, i int) bool { +func OverleftSpansetInt(ss *SpanSet, i int) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_spanset_int(ss._inner, C.int(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftSpansetSpan wraps MEOS C function overleft_spanset_span. -func OverleftSpansetSpan(ss *SpanSet, s *Span) bool { +func OverleftSpansetSpan(ss *SpanSet, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_spanset_span(ss._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftSpansetSpanset wraps MEOS C function overleft_spanset_spanset. -func OverleftSpansetSpanset(ss1 *SpanSet, ss2 *SpanSet) bool { +func OverleftSpansetSpanset(ss1 *SpanSet, ss2 *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_spanset_spanset(ss1._inner, ss2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftTextSet wraps MEOS C function overleft_text_set. -func OverleftTextSet(txt string, s *Set) bool { +func OverleftTextSet(txt string, s *Set) (_r0 bool, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.overleft_text_set(_c_txt, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightBigintSet wraps MEOS C function overright_bigint_set. -func OverrightBigintSet(i int64, s *Set) bool { +func OverrightBigintSet(i int64, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_bigint_set(C.int64_t(i), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightBigintSpan wraps MEOS C function overright_bigint_span. -func OverrightBigintSpan(i int64, s *Span) bool { +func OverrightBigintSpan(i int64, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_bigint_span(C.int64_t(i), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightBigintSpanset wraps MEOS C function overright_bigint_spanset. -func OverrightBigintSpanset(i int64, ss *SpanSet) bool { +func OverrightBigintSpanset(i int64, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_bigint_spanset(C.int64_t(i), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightFloatSet wraps MEOS C function overright_float_set. -func OverrightFloatSet(d float64, s *Set) bool { +func OverrightFloatSet(d float64, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_float_set(C.double(d), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightFloatSpan wraps MEOS C function overright_float_span. -func OverrightFloatSpan(d float64, s *Span) bool { +func OverrightFloatSpan(d float64, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_float_span(C.double(d), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightFloatSpanset wraps MEOS C function overright_float_spanset. -func OverrightFloatSpanset(d float64, ss *SpanSet) bool { +func OverrightFloatSpanset(d float64, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_float_spanset(C.double(d), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightIntSet wraps MEOS C function overright_int_set. -func OverrightIntSet(i int, s *Set) bool { +func OverrightIntSet(i int, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_int_set(C.int(i), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightIntSpan wraps MEOS C function overright_int_span. -func OverrightIntSpan(i int, s *Span) bool { +func OverrightIntSpan(i int, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_int_span(C.int(i), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightIntSpanset wraps MEOS C function overright_int_spanset. -func OverrightIntSpanset(i int, ss *SpanSet) bool { +func OverrightIntSpanset(i int, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_int_spanset(C.int(i), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightSetBigint wraps MEOS C function overright_set_bigint. -func OverrightSetBigint(s *Set, i int64) bool { +func OverrightSetBigint(s *Set, i int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_set_bigint(s._inner, C.int64_t(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightSetFloat wraps MEOS C function overright_set_float. -func OverrightSetFloat(s *Set, d float64) bool { +func OverrightSetFloat(s *Set, d float64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_set_float(s._inner, C.double(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightSetInt wraps MEOS C function overright_set_int. -func OverrightSetInt(s *Set, i int) bool { +func OverrightSetInt(s *Set, i int) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_set_int(s._inner, C.int(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightSetSet wraps MEOS C function overright_set_set. -func OverrightSetSet(s1 *Set, s2 *Set) bool { +func OverrightSetSet(s1 *Set, s2 *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_set_set(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightSetText wraps MEOS C function overright_set_text. -func OverrightSetText(s *Set, txt string) bool { +func OverrightSetText(s *Set, txt string) (_r0 bool, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.overright_set_text(s._inner, _c_txt) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightSpanBigint wraps MEOS C function overright_span_bigint. -func OverrightSpanBigint(s *Span, i int64) bool { +func OverrightSpanBigint(s *Span, i int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_span_bigint(s._inner, C.int64_t(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightSpanFloat wraps MEOS C function overright_span_float. -func OverrightSpanFloat(s *Span, d float64) bool { +func OverrightSpanFloat(s *Span, d float64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_span_float(s._inner, C.double(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightSpanInt wraps MEOS C function overright_span_int. -func OverrightSpanInt(s *Span, i int) bool { +func OverrightSpanInt(s *Span, i int) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_span_int(s._inner, C.int(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightSpanSpan wraps MEOS C function overright_span_span. -func OverrightSpanSpan(s1 *Span, s2 *Span) bool { +func OverrightSpanSpan(s1 *Span, s2 *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_span_span(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightSpanSpanset wraps MEOS C function overright_span_spanset. -func OverrightSpanSpanset(s *Span, ss *SpanSet) bool { +func OverrightSpanSpanset(s *Span, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_span_spanset(s._inner, ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightSpansetBigint wraps MEOS C function overright_spanset_bigint. -func OverrightSpansetBigint(ss *SpanSet, i int64) bool { +func OverrightSpansetBigint(ss *SpanSet, i int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_spanset_bigint(ss._inner, C.int64_t(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightSpansetFloat wraps MEOS C function overright_spanset_float. -func OverrightSpansetFloat(ss *SpanSet, d float64) bool { +func OverrightSpansetFloat(ss *SpanSet, d float64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_spanset_float(ss._inner, C.double(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightSpansetInt wraps MEOS C function overright_spanset_int. -func OverrightSpansetInt(ss *SpanSet, i int) bool { +func OverrightSpansetInt(ss *SpanSet, i int) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_spanset_int(ss._inner, C.int(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightSpansetSpan wraps MEOS C function overright_spanset_span. -func OverrightSpansetSpan(ss *SpanSet, s *Span) bool { +func OverrightSpansetSpan(ss *SpanSet, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_spanset_span(ss._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightSpansetSpanset wraps MEOS C function overright_spanset_spanset. -func OverrightSpansetSpanset(ss1 *SpanSet, ss2 *SpanSet) bool { +func OverrightSpansetSpanset(ss1 *SpanSet, ss2 *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_spanset_spanset(ss1._inner, ss2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightTextSet wraps MEOS C function overright_text_set. -func OverrightTextSet(txt string, s *Set) bool { +func OverrightTextSet(txt string, s *Set) (_r0 bool, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.overright_text_set(_c_txt, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightBigintSet wraps MEOS C function right_bigint_set. -func RightBigintSet(i int64, s *Set) bool { +func RightBigintSet(i int64, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_bigint_set(C.int64_t(i), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightBigintSpan wraps MEOS C function right_bigint_span. -func RightBigintSpan(i int64, s *Span) bool { +func RightBigintSpan(i int64, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_bigint_span(C.int64_t(i), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightBigintSpanset wraps MEOS C function right_bigint_spanset. -func RightBigintSpanset(i int64, ss *SpanSet) bool { +func RightBigintSpanset(i int64, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_bigint_spanset(C.int64_t(i), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightFloatSet wraps MEOS C function right_float_set. -func RightFloatSet(d float64, s *Set) bool { +func RightFloatSet(d float64, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_float_set(C.double(d), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightFloatSpan wraps MEOS C function right_float_span. -func RightFloatSpan(d float64, s *Span) bool { +func RightFloatSpan(d float64, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_float_span(C.double(d), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightFloatSpanset wraps MEOS C function right_float_spanset. -func RightFloatSpanset(d float64, ss *SpanSet) bool { +func RightFloatSpanset(d float64, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_float_spanset(C.double(d), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightIntSet wraps MEOS C function right_int_set. -func RightIntSet(i int, s *Set) bool { +func RightIntSet(i int, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_int_set(C.int(i), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightIntSpan wraps MEOS C function right_int_span. -func RightIntSpan(i int, s *Span) bool { +func RightIntSpan(i int, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_int_span(C.int(i), s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightIntSpanset wraps MEOS C function right_int_spanset. -func RightIntSpanset(i int, ss *SpanSet) bool { +func RightIntSpanset(i int, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_int_spanset(C.int(i), ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightSetBigint wraps MEOS C function right_set_bigint. -func RightSetBigint(s *Set, i int64) bool { +func RightSetBigint(s *Set, i int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_set_bigint(s._inner, C.int64_t(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightSetFloat wraps MEOS C function right_set_float. -func RightSetFloat(s *Set, d float64) bool { +func RightSetFloat(s *Set, d float64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_set_float(s._inner, C.double(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightSetInt wraps MEOS C function right_set_int. -func RightSetInt(s *Set, i int) bool { +func RightSetInt(s *Set, i int) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_set_int(s._inner, C.int(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightSetSet wraps MEOS C function right_set_set. -func RightSetSet(s1 *Set, s2 *Set) bool { +func RightSetSet(s1 *Set, s2 *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_set_set(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightSetText wraps MEOS C function right_set_text. -func RightSetText(s *Set, txt string) bool { +func RightSetText(s *Set, txt string) (_r0 bool, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.right_set_text(s._inner, _c_txt) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightSpanBigint wraps MEOS C function right_span_bigint. -func RightSpanBigint(s *Span, i int64) bool { +func RightSpanBigint(s *Span, i int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_span_bigint(s._inner, C.int64_t(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightSpanFloat wraps MEOS C function right_span_float. -func RightSpanFloat(s *Span, d float64) bool { +func RightSpanFloat(s *Span, d float64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_span_float(s._inner, C.double(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightSpanInt wraps MEOS C function right_span_int. -func RightSpanInt(s *Span, i int) bool { +func RightSpanInt(s *Span, i int) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_span_int(s._inner, C.int(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightSpanSpan wraps MEOS C function right_span_span. -func RightSpanSpan(s1 *Span, s2 *Span) bool { +func RightSpanSpan(s1 *Span, s2 *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_span_span(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightSpanSpanset wraps MEOS C function right_span_spanset. -func RightSpanSpanset(s *Span, ss *SpanSet) bool { +func RightSpanSpanset(s *Span, ss *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_span_spanset(s._inner, ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightSpansetBigint wraps MEOS C function right_spanset_bigint. -func RightSpansetBigint(ss *SpanSet, i int64) bool { +func RightSpansetBigint(ss *SpanSet, i int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_spanset_bigint(ss._inner, C.int64_t(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightSpansetFloat wraps MEOS C function right_spanset_float. -func RightSpansetFloat(ss *SpanSet, d float64) bool { +func RightSpansetFloat(ss *SpanSet, d float64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_spanset_float(ss._inner, C.double(d)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightSpansetInt wraps MEOS C function right_spanset_int. -func RightSpansetInt(ss *SpanSet, i int) bool { +func RightSpansetInt(ss *SpanSet, i int) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_spanset_int(ss._inner, C.int(i)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightSpansetSpan wraps MEOS C function right_spanset_span. -func RightSpansetSpan(ss *SpanSet, s *Span) bool { +func RightSpansetSpan(ss *SpanSet, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_spanset_span(ss._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightSpansetSpanset wraps MEOS C function right_spanset_spanset. -func RightSpansetSpanset(ss1 *SpanSet, ss2 *SpanSet) bool { +func RightSpansetSpanset(ss1 *SpanSet, ss2 *SpanSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_spanset_spanset(ss1._inner, ss2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightTextSet wraps MEOS C function right_text_set. -func RightTextSet(txt string, s *Set) bool { +func RightTextSet(txt string, s *Set) (_r0 bool, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.right_text_set(_c_txt, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // IntersectionBigintSet wraps MEOS C function intersection_bigint_set. -func IntersectionBigintSet(i int64, s *Set) *Set { +func IntersectionBigintSet(i int64, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_bigint_set(C.int64_t(i), s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntersectionDateSet wraps MEOS C function intersection_date_set. -func IntersectionDateSet(d int32, s *Set) *Set { +func IntersectionDateSet(d int32, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_date_set(C.DateADT(d), s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntersectionFloatSet wraps MEOS C function intersection_float_set. -func IntersectionFloatSet(d float64, s *Set) *Set { +func IntersectionFloatSet(d float64, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_float_set(C.double(d), s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntersectionIntSet wraps MEOS C function intersection_int_set. -func IntersectionIntSet(i int, s *Set) *Set { +func IntersectionIntSet(i int, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_int_set(C.int(i), s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntersectionSetBigint wraps MEOS C function intersection_set_bigint. -func IntersectionSetBigint(s *Set, i int64) *Set { +func IntersectionSetBigint(s *Set, i int64) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_set_bigint(s._inner, C.int64_t(i)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntersectionSetDate wraps MEOS C function intersection_set_date. -func IntersectionSetDate(s *Set, d int32) *Set { +func IntersectionSetDate(s *Set, d int32) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_set_date(s._inner, C.DateADT(d)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntersectionSetFloat wraps MEOS C function intersection_set_float. -func IntersectionSetFloat(s *Set, d float64) *Set { +func IntersectionSetFloat(s *Set, d float64) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_set_float(s._inner, C.double(d)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntersectionSetInt wraps MEOS C function intersection_set_int. -func IntersectionSetInt(s *Set, i int) *Set { +func IntersectionSetInt(s *Set, i int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_set_int(s._inner, C.int(i)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntersectionSetSet wraps MEOS C function intersection_set_set. -func IntersectionSetSet(s1 *Set, s2 *Set) *Set { +func IntersectionSetSet(s1 *Set, s2 *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_set_set(s1._inner, s2._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntersectionSetText wraps MEOS C function intersection_set_text. -func IntersectionSetText(s *Set, txt string) *Set { +func IntersectionSetText(s *Set, txt string) (_r0 *Set, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.intersection_set_text(s._inner, _c_txt) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntersectionSetTimestamptz wraps MEOS C function intersection_set_timestamptz. -func IntersectionSetTimestamptz(s *Set, t int64) *Set { +func IntersectionSetTimestamptz(s *Set, t int64) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_set_timestamptz(s._inner, C.TimestampTz(t)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntersectionSpanBigint wraps MEOS C function intersection_span_bigint. -func IntersectionSpanBigint(s *Span, i int64) *Span { +func IntersectionSpanBigint(s *Span, i int64) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.intersection_span_bigint(s._inner, C.int64_t(i)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // IntersectionSpanDate wraps MEOS C function intersection_span_date. -func IntersectionSpanDate(s *Span, d int32) *Span { +func IntersectionSpanDate(s *Span, d int32) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.intersection_span_date(s._inner, C.DateADT(d)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // IntersectionSpanFloat wraps MEOS C function intersection_span_float. -func IntersectionSpanFloat(s *Span, d float64) *Span { +func IntersectionSpanFloat(s *Span, d float64) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.intersection_span_float(s._inner, C.double(d)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // IntersectionSpanInt wraps MEOS C function intersection_span_int. -func IntersectionSpanInt(s *Span, i int) *Span { +func IntersectionSpanInt(s *Span, i int) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.intersection_span_int(s._inner, C.int(i)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // IntersectionSpanSpan wraps MEOS C function intersection_span_span. -func IntersectionSpanSpan(s1 *Span, s2 *Span) *Span { +func IntersectionSpanSpan(s1 *Span, s2 *Span) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.intersection_span_span(s1._inner, s2._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // IntersectionSpanSpanset wraps MEOS C function intersection_span_spanset. -func IntersectionSpanSpanset(s *Span, ss *SpanSet) *SpanSet { +func IntersectionSpanSpanset(s *Span, ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.intersection_span_spanset(s._inner, ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // IntersectionSpanTimestamptz wraps MEOS C function intersection_span_timestamptz. -func IntersectionSpanTimestamptz(s *Span, t int64) *Span { +func IntersectionSpanTimestamptz(s *Span, t int64) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.intersection_span_timestamptz(s._inner, C.TimestampTz(t)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // IntersectionSpansetBigint wraps MEOS C function intersection_spanset_bigint. -func IntersectionSpansetBigint(ss *SpanSet, i int64) *SpanSet { +func IntersectionSpansetBigint(ss *SpanSet, i int64) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.intersection_spanset_bigint(ss._inner, C.int64_t(i)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // IntersectionSpansetDate wraps MEOS C function intersection_spanset_date. -func IntersectionSpansetDate(ss *SpanSet, d int32) *SpanSet { +func IntersectionSpansetDate(ss *SpanSet, d int32) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.intersection_spanset_date(ss._inner, C.DateADT(d)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // IntersectionSpansetFloat wraps MEOS C function intersection_spanset_float. -func IntersectionSpansetFloat(ss *SpanSet, d float64) *SpanSet { +func IntersectionSpansetFloat(ss *SpanSet, d float64) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.intersection_spanset_float(ss._inner, C.double(d)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // IntersectionSpansetInt wraps MEOS C function intersection_spanset_int. -func IntersectionSpansetInt(ss *SpanSet, i int) *SpanSet { +func IntersectionSpansetInt(ss *SpanSet, i int) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.intersection_spanset_int(ss._inner, C.int(i)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // IntersectionSpansetSpan wraps MEOS C function intersection_spanset_span. -func IntersectionSpansetSpan(ss *SpanSet, s *Span) *SpanSet { +func IntersectionSpansetSpan(ss *SpanSet, s *Span) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.intersection_spanset_span(ss._inner, s._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // IntersectionSpansetSpanset wraps MEOS C function intersection_spanset_spanset. -func IntersectionSpansetSpanset(ss1 *SpanSet, ss2 *SpanSet) *SpanSet { +func IntersectionSpansetSpanset(ss1 *SpanSet, ss2 *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.intersection_spanset_spanset(ss1._inner, ss2._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // IntersectionSpansetTimestamptz wraps MEOS C function intersection_spanset_timestamptz. -func IntersectionSpansetTimestamptz(ss *SpanSet, t int64) *SpanSet { +func IntersectionSpansetTimestamptz(ss *SpanSet, t int64) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.intersection_spanset_timestamptz(ss._inner, C.TimestampTz(t)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // IntersectionTextSet wraps MEOS C function intersection_text_set. -func IntersectionTextSet(txt string, s *Set) *Set { +func IntersectionTextSet(txt string, s *Set) (_r0 *Set, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.intersection_text_set(_c_txt, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntersectionTimestamptzSet wraps MEOS C function intersection_timestamptz_set. -func IntersectionTimestamptzSet(t int64, s *Set) *Set { +func IntersectionTimestamptzSet(t int64, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_timestamptz_set(C.TimestampTz(t), s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusBigintSet wraps MEOS C function minus_bigint_set. -func MinusBigintSet(i int64, s *Set) *Set { +func MinusBigintSet(i int64, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_bigint_set(C.int64_t(i), s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusBigintSpan wraps MEOS C function minus_bigint_span. -func MinusBigintSpan(i int64, s *Span) *SpanSet { +func MinusBigintSpan(i int64, s *Span) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_bigint_span(C.int64_t(i), s._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusBigintSpanset wraps MEOS C function minus_bigint_spanset. -func MinusBigintSpanset(i int64, ss *SpanSet) *SpanSet { +func MinusBigintSpanset(i int64, ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_bigint_spanset(C.int64_t(i), ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusDateSet wraps MEOS C function minus_date_set. -func MinusDateSet(d int32, s *Set) *Set { +func MinusDateSet(d int32, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_date_set(C.DateADT(d), s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusDateSpan wraps MEOS C function minus_date_span. -func MinusDateSpan(d int32, s *Span) *SpanSet { +func MinusDateSpan(d int32, s *Span) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_date_span(C.DateADT(d), s._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusDateSpanset wraps MEOS C function minus_date_spanset. -func MinusDateSpanset(d int32, ss *SpanSet) *SpanSet { +func MinusDateSpanset(d int32, ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_date_spanset(C.DateADT(d), ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusFloatSet wraps MEOS C function minus_float_set. -func MinusFloatSet(d float64, s *Set) *Set { +func MinusFloatSet(d float64, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_float_set(C.double(d), s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusFloatSpan wraps MEOS C function minus_float_span. -func MinusFloatSpan(d float64, s *Span) *SpanSet { +func MinusFloatSpan(d float64, s *Span) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_float_span(C.double(d), s._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusFloatSpanset wraps MEOS C function minus_float_spanset. -func MinusFloatSpanset(d float64, ss *SpanSet) *SpanSet { +func MinusFloatSpanset(d float64, ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_float_spanset(C.double(d), ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusIntSet wraps MEOS C function minus_int_set. -func MinusIntSet(i int, s *Set) *Set { +func MinusIntSet(i int, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_int_set(C.int(i), s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusIntSpan wraps MEOS C function minus_int_span. -func MinusIntSpan(i int, s *Span) *SpanSet { +func MinusIntSpan(i int, s *Span) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_int_span(C.int(i), s._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusIntSpanset wraps MEOS C function minus_int_spanset. -func MinusIntSpanset(i int, ss *SpanSet) *SpanSet { +func MinusIntSpanset(i int, ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_int_spanset(C.int(i), ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusSetBigint wraps MEOS C function minus_set_bigint. -func MinusSetBigint(s *Set, i int64) *Set { +func MinusSetBigint(s *Set, i int64) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_set_bigint(s._inner, C.int64_t(i)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusSetDate wraps MEOS C function minus_set_date. -func MinusSetDate(s *Set, d int32) *Set { +func MinusSetDate(s *Set, d int32) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_set_date(s._inner, C.DateADT(d)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusSetFloat wraps MEOS C function minus_set_float. -func MinusSetFloat(s *Set, d float64) *Set { +func MinusSetFloat(s *Set, d float64) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_set_float(s._inner, C.double(d)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusSetInt wraps MEOS C function minus_set_int. -func MinusSetInt(s *Set, i int) *Set { +func MinusSetInt(s *Set, i int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_set_int(s._inner, C.int(i)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusSetSet wraps MEOS C function minus_set_set. -func MinusSetSet(s1 *Set, s2 *Set) *Set { +func MinusSetSet(s1 *Set, s2 *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_set_set(s1._inner, s2._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusSetText wraps MEOS C function minus_set_text. -func MinusSetText(s *Set, txt string) *Set { +func MinusSetText(s *Set, txt string) (_r0 *Set, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.minus_set_text(s._inner, _c_txt) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusSetTimestamptz wraps MEOS C function minus_set_timestamptz. -func MinusSetTimestamptz(s *Set, t int64) *Set { +func MinusSetTimestamptz(s *Set, t int64) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_set_timestamptz(s._inner, C.TimestampTz(t)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusSpanBigint wraps MEOS C function minus_span_bigint. -func MinusSpanBigint(s *Span, i int64) *SpanSet { +func MinusSpanBigint(s *Span, i int64) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_span_bigint(s._inner, C.int64_t(i)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusSpanDate wraps MEOS C function minus_span_date. -func MinusSpanDate(s *Span, d int32) *SpanSet { +func MinusSpanDate(s *Span, d int32) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_span_date(s._inner, C.DateADT(d)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusSpanFloat wraps MEOS C function minus_span_float. -func MinusSpanFloat(s *Span, d float64) *SpanSet { +func MinusSpanFloat(s *Span, d float64) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_span_float(s._inner, C.double(d)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusSpanInt wraps MEOS C function minus_span_int. -func MinusSpanInt(s *Span, i int) *SpanSet { +func MinusSpanInt(s *Span, i int) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_span_int(s._inner, C.int(i)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusSpanSpan wraps MEOS C function minus_span_span. -func MinusSpanSpan(s1 *Span, s2 *Span) *SpanSet { +func MinusSpanSpan(s1 *Span, s2 *Span) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_span_span(s1._inner, s2._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusSpanSpanset wraps MEOS C function minus_span_spanset. -func MinusSpanSpanset(s *Span, ss *SpanSet) *SpanSet { +func MinusSpanSpanset(s *Span, ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_span_spanset(s._inner, ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusSpanTimestamptz wraps MEOS C function minus_span_timestamptz. -func MinusSpanTimestamptz(s *Span, t int64) *SpanSet { +func MinusSpanTimestamptz(s *Span, t int64) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_span_timestamptz(s._inner, C.TimestampTz(t)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusSpansetBigint wraps MEOS C function minus_spanset_bigint. -func MinusSpansetBigint(ss *SpanSet, i int64) *SpanSet { +func MinusSpansetBigint(ss *SpanSet, i int64) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_spanset_bigint(ss._inner, C.int64_t(i)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusSpansetDate wraps MEOS C function minus_spanset_date. -func MinusSpansetDate(ss *SpanSet, d int32) *SpanSet { +func MinusSpansetDate(ss *SpanSet, d int32) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_spanset_date(ss._inner, C.DateADT(d)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusSpansetFloat wraps MEOS C function minus_spanset_float. -func MinusSpansetFloat(ss *SpanSet, d float64) *SpanSet { +func MinusSpansetFloat(ss *SpanSet, d float64) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_spanset_float(ss._inner, C.double(d)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusSpansetInt wraps MEOS C function minus_spanset_int. -func MinusSpansetInt(ss *SpanSet, i int) *SpanSet { +func MinusSpansetInt(ss *SpanSet, i int) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_spanset_int(ss._inner, C.int(i)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusSpansetSpan wraps MEOS C function minus_spanset_span. -func MinusSpansetSpan(ss *SpanSet, s *Span) *SpanSet { +func MinusSpansetSpan(ss *SpanSet, s *Span) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_spanset_span(ss._inner, s._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusSpansetSpanset wraps MEOS C function minus_spanset_spanset. -func MinusSpansetSpanset(ss1 *SpanSet, ss2 *SpanSet) *SpanSet { +func MinusSpansetSpanset(ss1 *SpanSet, ss2 *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_spanset_spanset(ss1._inner, ss2._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusSpansetTimestamptz wraps MEOS C function minus_spanset_timestamptz. -func MinusSpansetTimestamptz(ss *SpanSet, t int64) *SpanSet { +func MinusSpansetTimestamptz(ss *SpanSet, t int64) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_spanset_timestamptz(ss._inner, C.TimestampTz(t)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusTextSet wraps MEOS C function minus_text_set. -func MinusTextSet(txt string, s *Set) *Set { +func MinusTextSet(txt string, s *Set) (_r0 *Set, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.minus_text_set(_c_txt, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusTimestamptzSet wraps MEOS C function minus_timestamptz_set. -func MinusTimestamptzSet(t int64, s *Set) *Set { +func MinusTimestamptzSet(t int64, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_timestamptz_set(C.TimestampTz(t), s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusTimestamptzSpan wraps MEOS C function minus_timestamptz_span. -func MinusTimestamptzSpan(t int64, s *Span) *SpanSet { +func MinusTimestamptzSpan(t int64, s *Span) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_timestamptz_span(C.TimestampTz(t), s._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // MinusTimestamptzSpanset wraps MEOS C function minus_timestamptz_spanset. -func MinusTimestamptzSpanset(t int64, ss *SpanSet) *SpanSet { +func MinusTimestamptzSpanset(t int64, ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.minus_timestamptz_spanset(C.TimestampTz(t), ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionBigintSet wraps MEOS C function union_bigint_set. -func UnionBigintSet(i int64, s *Set) *Set { +func UnionBigintSet(i int64, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_bigint_set(C.int64_t(i), s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionBigintSpan wraps MEOS C function union_bigint_span. -func UnionBigintSpan(i int64, s *Span) *SpanSet { +func UnionBigintSpan(i int64, s *Span) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_bigint_span(C.int64_t(i), s._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionBigintSpanset wraps MEOS C function union_bigint_spanset. -func UnionBigintSpanset(i int64, ss *SpanSet) *SpanSet { +func UnionBigintSpanset(i int64, ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_bigint_spanset(C.int64_t(i), ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionDateSet wraps MEOS C function union_date_set. -func UnionDateSet(d int32, s *Set) *Set { +func UnionDateSet(d int32, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_date_set(C.DateADT(d), s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionDateSpan wraps MEOS C function union_date_span. -func UnionDateSpan(d int32, s *Span) *SpanSet { +func UnionDateSpan(d int32, s *Span) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_date_span(C.DateADT(d), s._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionDateSpanset wraps MEOS C function union_date_spanset. -func UnionDateSpanset(d int32, ss *SpanSet) *SpanSet { +func UnionDateSpanset(d int32, ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_date_spanset(C.DateADT(d), ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionFloatSet wraps MEOS C function union_float_set. -func UnionFloatSet(d float64, s *Set) *Set { +func UnionFloatSet(d float64, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_float_set(C.double(d), s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionFloatSpan wraps MEOS C function union_float_span. -func UnionFloatSpan(d float64, s *Span) *SpanSet { +func UnionFloatSpan(d float64, s *Span) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_float_span(C.double(d), s._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionFloatSpanset wraps MEOS C function union_float_spanset. -func UnionFloatSpanset(d float64, ss *SpanSet) *SpanSet { +func UnionFloatSpanset(d float64, ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_float_spanset(C.double(d), ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionIntSet wraps MEOS C function union_int_set. -func UnionIntSet(i int, s *Set) *Set { +func UnionIntSet(i int, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_int_set(C.int(i), s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionIntSpan wraps MEOS C function union_int_span. -func UnionIntSpan(i int, s *Span) *SpanSet { +func UnionIntSpan(i int, s *Span) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_int_span(C.int(i), s._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionIntSpanset wraps MEOS C function union_int_spanset. -func UnionIntSpanset(i int, ss *SpanSet) *SpanSet { +func UnionIntSpanset(i int, ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_int_spanset(C.int(i), ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionSetBigint wraps MEOS C function union_set_bigint. -func UnionSetBigint(s *Set, i int64) *Set { +func UnionSetBigint(s *Set, i int64) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_set_bigint(s._inner, C.int64_t(i)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionSetDate wraps MEOS C function union_set_date. -func UnionSetDate(s *Set, d int32) *Set { +func UnionSetDate(s *Set, d int32) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_set_date(s._inner, C.DateADT(d)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionSetFloat wraps MEOS C function union_set_float. -func UnionSetFloat(s *Set, d float64) *Set { +func UnionSetFloat(s *Set, d float64) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_set_float(s._inner, C.double(d)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionSetInt wraps MEOS C function union_set_int. -func UnionSetInt(s *Set, i int) *Set { +func UnionSetInt(s *Set, i int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_set_int(s._inner, C.int(i)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionSetSet wraps MEOS C function union_set_set. -func UnionSetSet(s1 *Set, s2 *Set) *Set { +func UnionSetSet(s1 *Set, s2 *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_set_set(s1._inner, s2._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionSetText wraps MEOS C function union_set_text. -func UnionSetText(s *Set, txt string) *Set { +func UnionSetText(s *Set, txt string) (_r0 *Set, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.gunion_set_text(s._inner, _c_txt) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionSetTimestamptz wraps MEOS C function union_set_timestamptz. -func UnionSetTimestamptz(s *Set, t int64) *Set { +func UnionSetTimestamptz(s *Set, t int64) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_set_timestamptz(s._inner, C.TimestampTz(t)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionSpanBigint wraps MEOS C function union_span_bigint. -func UnionSpanBigint(s *Span, i int64) *SpanSet { +func UnionSpanBigint(s *Span, i int64) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_span_bigint(s._inner, C.int64_t(i)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionSpanDate wraps MEOS C function union_span_date. -func UnionSpanDate(s *Span, d int32) *SpanSet { +func UnionSpanDate(s *Span, d int32) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_span_date(s._inner, C.DateADT(d)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionSpanFloat wraps MEOS C function union_span_float. -func UnionSpanFloat(s *Span, d float64) *SpanSet { +func UnionSpanFloat(s *Span, d float64) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_span_float(s._inner, C.double(d)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionSpanInt wraps MEOS C function union_span_int. -func UnionSpanInt(s *Span, i int) *SpanSet { +func UnionSpanInt(s *Span, i int) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_span_int(s._inner, C.int(i)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionSpanSpan wraps MEOS C function union_span_span. -func UnionSpanSpan(s1 *Span, s2 *Span) *SpanSet { +func UnionSpanSpan(s1 *Span, s2 *Span) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_span_span(s1._inner, s2._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionSpanSpanset wraps MEOS C function union_span_spanset. -func UnionSpanSpanset(s *Span, ss *SpanSet) *SpanSet { +func UnionSpanSpanset(s *Span, ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_span_spanset(s._inner, ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionSpanTimestamptz wraps MEOS C function union_span_timestamptz. -func UnionSpanTimestamptz(s *Span, t int64) *SpanSet { +func UnionSpanTimestamptz(s *Span, t int64) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_span_timestamptz(s._inner, C.TimestampTz(t)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionSpansetBigint wraps MEOS C function union_spanset_bigint. -func UnionSpansetBigint(ss *SpanSet, i int64) *SpanSet { +func UnionSpansetBigint(ss *SpanSet, i int64) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_spanset_bigint(ss._inner, C.int64_t(i)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionSpansetDate wraps MEOS C function union_spanset_date. -func UnionSpansetDate(ss *SpanSet, d int32) *SpanSet { +func UnionSpansetDate(ss *SpanSet, d int32) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_spanset_date(ss._inner, C.DateADT(d)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionSpansetFloat wraps MEOS C function union_spanset_float. -func UnionSpansetFloat(ss *SpanSet, d float64) *SpanSet { +func UnionSpansetFloat(ss *SpanSet, d float64) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_spanset_float(ss._inner, C.double(d)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionSpansetInt wraps MEOS C function union_spanset_int. -func UnionSpansetInt(ss *SpanSet, i int) *SpanSet { +func UnionSpansetInt(ss *SpanSet, i int) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_spanset_int(ss._inner, C.int(i)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionSpansetSpan wraps MEOS C function union_spanset_span. -func UnionSpansetSpan(ss *SpanSet, s *Span) *SpanSet { +func UnionSpansetSpan(ss *SpanSet, s *Span) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_spanset_span(ss._inner, s._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionSpansetSpanset wraps MEOS C function union_spanset_spanset. -func UnionSpansetSpanset(ss1 *SpanSet, ss2 *SpanSet) *SpanSet { +func UnionSpansetSpanset(ss1 *SpanSet, ss2 *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_spanset_spanset(ss1._inner, ss2._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionSpansetTimestamptz wraps MEOS C function union_spanset_timestamptz. -func UnionSpansetTimestamptz(ss *SpanSet, t int64) *SpanSet { +func UnionSpansetTimestamptz(ss *SpanSet, t int64) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_spanset_timestamptz(ss._inner, C.TimestampTz(t)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionTextSet wraps MEOS C function union_text_set. -func UnionTextSet(txt string, s *Set) *Set { +func UnionTextSet(txt string, s *Set) (_r0 *Set, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.gunion_text_set(_c_txt, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionTimestamptzSet wraps MEOS C function union_timestamptz_set. -func UnionTimestamptzSet(t int64, s *Set) *Set { +func UnionTimestamptzSet(t int64, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_timestamptz_set(C.TimestampTz(t), s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionTimestamptzSpan wraps MEOS C function union_timestamptz_span. -func UnionTimestamptzSpan(t int64, s *Span) *SpanSet { +func UnionTimestamptzSpan(t int64, s *Span) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_timestamptz_span(C.TimestampTz(t), s._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // UnionTimestamptzSpanset wraps MEOS C function union_timestamptz_spanset. -func UnionTimestamptzSpanset(t int64, ss *SpanSet) *SpanSet { +func UnionTimestamptzSpanset(t int64, ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.gunion_timestamptz_spanset(C.TimestampTz(t), ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // DistanceBigintsetBigintset wraps MEOS C function distance_bigintset_bigintset. -func DistanceBigintsetBigintset(s1 *Set, s2 *Set) int64 { +func DistanceBigintsetBigintset(s1 *Set, s2 *Set) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.distance_bigintset_bigintset(s1._inner, s2._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // DistanceBigintspanBigintspan wraps MEOS C function distance_bigintspan_bigintspan. -func DistanceBigintspanBigintspan(s1 *Span, s2 *Span) int64 { +func DistanceBigintspanBigintspan(s1 *Span, s2 *Span) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.distance_bigintspan_bigintspan(s1._inner, s2._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // DistanceBigintspansetBigintspan wraps MEOS C function distance_bigintspanset_bigintspan. -func DistanceBigintspansetBigintspan(ss *SpanSet, s *Span) int64 { +func DistanceBigintspansetBigintspan(ss *SpanSet, s *Span) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.distance_bigintspanset_bigintspan(ss._inner, s._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // DistanceBigintspansetBigintspanset wraps MEOS C function distance_bigintspanset_bigintspanset. -func DistanceBigintspansetBigintspanset(ss1 *SpanSet, ss2 *SpanSet) int64 { +func DistanceBigintspansetBigintspanset(ss1 *SpanSet, ss2 *SpanSet) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.distance_bigintspanset_bigintspanset(ss1._inner, ss2._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // DistanceDatesetDateset wraps MEOS C function distance_dateset_dateset. -func DistanceDatesetDateset(s1 *Set, s2 *Set) int { +func DistanceDatesetDateset(s1 *Set, s2 *Set) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.distance_dateset_dateset(s1._inner, s2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // DistanceDatespanDatespan wraps MEOS C function distance_datespan_datespan. -func DistanceDatespanDatespan(s1 *Span, s2 *Span) int { +func DistanceDatespanDatespan(s1 *Span, s2 *Span) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.distance_datespan_datespan(s1._inner, s2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // DistanceDatespansetDatespan wraps MEOS C function distance_datespanset_datespan. -func DistanceDatespansetDatespan(ss *SpanSet, s *Span) int { +func DistanceDatespansetDatespan(ss *SpanSet, s *Span) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.distance_datespanset_datespan(ss._inner, s._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // DistanceDatespansetDatespanset wraps MEOS C function distance_datespanset_datespanset. -func DistanceDatespansetDatespanset(ss1 *SpanSet, ss2 *SpanSet) int { +func DistanceDatespansetDatespanset(ss1 *SpanSet, ss2 *SpanSet) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.distance_datespanset_datespanset(ss1._inner, ss2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // DistanceFloatsetFloatset wraps MEOS C function distance_floatset_floatset. -func DistanceFloatsetFloatset(s1 *Set, s2 *Set) float64 { +func DistanceFloatsetFloatset(s1 *Set, s2 *Set) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.distance_floatset_floatset(s1._inner, s2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // DistanceFloatspanFloatspan wraps MEOS C function distance_floatspan_floatspan. -func DistanceFloatspanFloatspan(s1 *Span, s2 *Span) float64 { +func DistanceFloatspanFloatspan(s1 *Span, s2 *Span) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.distance_floatspan_floatspan(s1._inner, s2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // DistanceFloatspansetFloatspan wraps MEOS C function distance_floatspanset_floatspan. -func DistanceFloatspansetFloatspan(ss *SpanSet, s *Span) float64 { +func DistanceFloatspansetFloatspan(ss *SpanSet, s *Span) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.distance_floatspanset_floatspan(ss._inner, s._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // DistanceFloatspansetFloatspanset wraps MEOS C function distance_floatspanset_floatspanset. -func DistanceFloatspansetFloatspanset(ss1 *SpanSet, ss2 *SpanSet) float64 { +func DistanceFloatspansetFloatspanset(ss1 *SpanSet, ss2 *SpanSet) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.distance_floatspanset_floatspanset(ss1._inner, ss2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // DistanceIntsetIntset wraps MEOS C function distance_intset_intset. -func DistanceIntsetIntset(s1 *Set, s2 *Set) int { +func DistanceIntsetIntset(s1 *Set, s2 *Set) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.distance_intset_intset(s1._inner, s2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // DistanceIntspanIntspan wraps MEOS C function distance_intspan_intspan. -func DistanceIntspanIntspan(s1 *Span, s2 *Span) int { +func DistanceIntspanIntspan(s1 *Span, s2 *Span) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.distance_intspan_intspan(s1._inner, s2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // DistanceIntspansetIntspan wraps MEOS C function distance_intspanset_intspan. -func DistanceIntspansetIntspan(ss *SpanSet, s *Span) int { +func DistanceIntspansetIntspan(ss *SpanSet, s *Span) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.distance_intspanset_intspan(ss._inner, s._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // DistanceIntspansetIntspanset wraps MEOS C function distance_intspanset_intspanset. -func DistanceIntspansetIntspanset(ss1 *SpanSet, ss2 *SpanSet) int { +func DistanceIntspansetIntspanset(ss1 *SpanSet, ss2 *SpanSet) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.distance_intspanset_intspanset(ss1._inner, ss2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // DistanceSetBigint wraps MEOS C function distance_set_bigint. -func DistanceSetBigint(s *Set, i int64) int64 { +func DistanceSetBigint(s *Set, i int64) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.distance_set_bigint(s._inner, C.int64_t(i)) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // DistanceSetDate wraps MEOS C function distance_set_date. -func DistanceSetDate(s *Set, d int32) int { +func DistanceSetDate(s *Set, d int32) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.distance_set_date(s._inner, C.DateADT(d)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // DistanceSetFloat wraps MEOS C function distance_set_float. -func DistanceSetFloat(s *Set, d float64) float64 { +func DistanceSetFloat(s *Set, d float64) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.distance_set_float(s._inner, C.double(d)) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // DistanceSetInt wraps MEOS C function distance_set_int. -func DistanceSetInt(s *Set, i int) int { +func DistanceSetInt(s *Set, i int) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.distance_set_int(s._inner, C.int(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // DistanceSetTimestamptz wraps MEOS C function distance_set_timestamptz. -func DistanceSetTimestamptz(s *Set, t int64) float64 { +func DistanceSetTimestamptz(s *Set, t int64) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.distance_set_timestamptz(s._inner, C.TimestampTz(t)) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // DistanceSpanBigint wraps MEOS C function distance_span_bigint. -func DistanceSpanBigint(s *Span, i int64) int64 { +func DistanceSpanBigint(s *Span, i int64) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.distance_span_bigint(s._inner, C.int64_t(i)) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // DistanceSpanDate wraps MEOS C function distance_span_date. -func DistanceSpanDate(s *Span, d int32) int { +func DistanceSpanDate(s *Span, d int32) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.distance_span_date(s._inner, C.DateADT(d)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // DistanceSpanFloat wraps MEOS C function distance_span_float. -func DistanceSpanFloat(s *Span, d float64) float64 { +func DistanceSpanFloat(s *Span, d float64) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.distance_span_float(s._inner, C.double(d)) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // DistanceSpanInt wraps MEOS C function distance_span_int. -func DistanceSpanInt(s *Span, i int) int { +func DistanceSpanInt(s *Span, i int) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.distance_span_int(s._inner, C.int(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // DistanceSpanTimestamptz wraps MEOS C function distance_span_timestamptz. -func DistanceSpanTimestamptz(s *Span, t int64) float64 { +func DistanceSpanTimestamptz(s *Span, t int64) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.distance_span_timestamptz(s._inner, C.TimestampTz(t)) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // DistanceSpansetBigint wraps MEOS C function distance_spanset_bigint. -func DistanceSpansetBigint(ss *SpanSet, i int64) int64 { +func DistanceSpansetBigint(ss *SpanSet, i int64) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.distance_spanset_bigint(ss._inner, C.int64_t(i)) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // DistanceSpansetDate wraps MEOS C function distance_spanset_date. -func DistanceSpansetDate(ss *SpanSet, d int32) int { +func DistanceSpansetDate(ss *SpanSet, d int32) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.distance_spanset_date(ss._inner, C.DateADT(d)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // DistanceSpansetFloat wraps MEOS C function distance_spanset_float. -func DistanceSpansetFloat(ss *SpanSet, d float64) float64 { +func DistanceSpansetFloat(ss *SpanSet, d float64) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.distance_spanset_float(ss._inner, C.double(d)) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // DistanceSpansetInt wraps MEOS C function distance_spanset_int. -func DistanceSpansetInt(ss *SpanSet, i int) int { +func DistanceSpansetInt(ss *SpanSet, i int) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.distance_spanset_int(ss._inner, C.int(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // DistanceSpansetTimestamptz wraps MEOS C function distance_spanset_timestamptz. -func DistanceSpansetTimestamptz(ss *SpanSet, t int64) float64 { +func DistanceSpansetTimestamptz(ss *SpanSet, t int64) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.distance_spanset_timestamptz(ss._inner, C.TimestampTz(t)) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // DistanceTstzsetTstzset wraps MEOS C function distance_tstzset_tstzset. -func DistanceTstzsetTstzset(s1 *Set, s2 *Set) float64 { +func DistanceTstzsetTstzset(s1 *Set, s2 *Set) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.distance_tstzset_tstzset(s1._inner, s2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // DistanceTstzspanTstzspan wraps MEOS C function distance_tstzspan_tstzspan. -func DistanceTstzspanTstzspan(s1 *Span, s2 *Span) float64 { +func DistanceTstzspanTstzspan(s1 *Span, s2 *Span) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.distance_tstzspan_tstzspan(s1._inner, s2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // DistanceTstzspansetTstzspan wraps MEOS C function distance_tstzspanset_tstzspan. -func DistanceTstzspansetTstzspan(ss *SpanSet, s *Span) float64 { +func DistanceTstzspansetTstzspan(ss *SpanSet, s *Span) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.distance_tstzspanset_tstzspan(ss._inner, s._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // DistanceTstzspansetTstzspanset wraps MEOS C function distance_tstzspanset_tstzspanset. -func DistanceTstzspansetTstzspanset(ss1 *SpanSet, ss2 *SpanSet) float64 { +func DistanceTstzspansetTstzspanset(ss1 *SpanSet, ss2 *SpanSet) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.distance_tstzspanset_tstzspanset(ss1._inner, ss2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // BigintExtentTransfn wraps MEOS C function bigint_extent_transfn. -func BigintExtentTransfn(state *Span, i int64) *Span { +func BigintExtentTransfn(state *Span, i int64) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.bigint_extent_transfn(state._inner, C.int64_t(i)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // BigintUnionTransfn wraps MEOS C function bigint_union_transfn. -func BigintUnionTransfn(state *Set, i int64) *Set { +func BigintUnionTransfn(state *Set, i int64) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.bigint_union_transfn(state._inner, C.int64_t(i)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // DateExtentTransfn wraps MEOS C function date_extent_transfn. -func DateExtentTransfn(state *Span, d int32) *Span { +func DateExtentTransfn(state *Span, d int32) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.date_extent_transfn(state._inner, C.DateADT(d)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // DateUnionTransfn wraps MEOS C function date_union_transfn. -func DateUnionTransfn(state *Set, d int32) *Set { +func DateUnionTransfn(state *Set, d int32) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.date_union_transfn(state._inner, C.DateADT(d)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // FloatExtentTransfn wraps MEOS C function float_extent_transfn. -func FloatExtentTransfn(state *Span, d float64) *Span { +func FloatExtentTransfn(state *Span, d float64) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.float_extent_transfn(state._inner, C.double(d)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // FloatUnionTransfn wraps MEOS C function float_union_transfn. -func FloatUnionTransfn(state *Set, d float64) *Set { +func FloatUnionTransfn(state *Set, d float64) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.float_union_transfn(state._inner, C.double(d)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntExtentTransfn wraps MEOS C function int_extent_transfn. -func IntExtentTransfn(state *Span, i int) *Span { +func IntExtentTransfn(state *Span, i int) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.int_extent_transfn(state._inner, C.int(i)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // IntUnionTransfn wraps MEOS C function int_union_transfn. -func IntUnionTransfn(state *Set, i int32) *Set { +func IntUnionTransfn(state *Set, i int32) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.int_union_transfn(state._inner, C.int32(i)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // SetExtentTransfn wraps MEOS C function set_extent_transfn. -func SetExtentTransfn(state *Span, s *Set) *Span { +func SetExtentTransfn(state *Span, s *Set) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.set_extent_transfn(state._inner, s._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // SetUnionFinalfn wraps MEOS C function set_union_finalfn. -func SetUnionFinalfn(state *Set) *Set { +func SetUnionFinalfn(state *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.set_union_finalfn(state._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // SetUnionTransfn wraps MEOS C function set_union_transfn. -func SetUnionTransfn(state *Set, s *Set) *Set { +func SetUnionTransfn(state *Set, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.set_union_transfn(state._inner, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // SpanExtentTransfn wraps MEOS C function span_extent_transfn. -func SpanExtentTransfn(state *Span, s *Span) *Span { +func SpanExtentTransfn(state *Span, s *Span) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.span_extent_transfn(state._inner, s._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // SpanUnionTransfn wraps MEOS C function span_union_transfn. -func SpanUnionTransfn(state *SpanSet, s *Span) *SpanSet { +func SpanUnionTransfn(state *SpanSet, s *Span) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.span_union_transfn(state._inner, s._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // SpansetExtentTransfn wraps MEOS C function spanset_extent_transfn. -func SpansetExtentTransfn(state *Span, ss *SpanSet) *Span { +func SpansetExtentTransfn(state *Span, ss *SpanSet) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.spanset_extent_transfn(state._inner, ss._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // SpansetUnionFinalfn wraps MEOS C function spanset_union_finalfn. -func SpansetUnionFinalfn(state *SpanSet) *SpanSet { +func SpansetUnionFinalfn(state *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.spanset_union_finalfn(state._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // SpansetUnionTransfn wraps MEOS C function spanset_union_transfn. -func SpansetUnionTransfn(state *SpanSet, ss *SpanSet) *SpanSet { +func SpansetUnionTransfn(state *SpanSet, ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.spanset_union_transfn(state._inner, ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // TextUnionTransfn wraps MEOS C function text_union_transfn. -func TextUnionTransfn(state *Set, txt string) *Set { +func TextUnionTransfn(state *Set, txt string) (_r0 *Set, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.text_union_transfn(state._inner, _c_txt) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TimestamptzExtentTransfn wraps MEOS C function timestamptz_extent_transfn. -func TimestamptzExtentTransfn(state *Span, t int64) *Span { +func TimestamptzExtentTransfn(state *Span, t int64) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.timestamptz_extent_transfn(state._inner, C.TimestampTz(t)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TimestamptzUnionTransfn wraps MEOS C function timestamptz_union_transfn. -func TimestamptzUnionTransfn(state *Set, t int64) *Set { +func TimestamptzUnionTransfn(state *Set, t int64) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.timestamptz_union_transfn(state._inner, C.TimestampTz(t)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // BigintGetBin wraps MEOS C function bigint_get_bin. -func BigintGetBin(value int64, vsize int64, vorigin int64) int64 { +func BigintGetBin(value int64, vsize int64, vorigin int64) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.bigint_get_bin(C.int64_t(value), C.int64_t(vsize), C.int64_t(vorigin)) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // BigintspanBins wraps MEOS C function bigintspan_bins. -func BigintspanBins(s *Span, vsize int64, vorigin int64, count unsafe.Pointer) *Span { +func BigintspanBins(s *Span, vsize int64, vorigin int64, count unsafe.Pointer) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.bigintspan_bins(s._inner, C.int64_t(vsize), C.int64_t(vorigin), (*C.int)(unsafe.Pointer(count))) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // BigintspansetBins wraps MEOS C function bigintspanset_bins. -func BigintspansetBins(ss *SpanSet, vsize int64, vorigin int64, count unsafe.Pointer) *Span { +func BigintspansetBins(ss *SpanSet, vsize int64, vorigin int64, count unsafe.Pointer) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.bigintspanset_bins(ss._inner, C.int64_t(vsize), C.int64_t(vorigin), (*C.int)(unsafe.Pointer(count))) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // DateGetBin wraps MEOS C function date_get_bin. -func DateGetBin(d int32, duration *Interval, torigin int32) int32 { +func DateGetBin(d int32, duration *Interval, torigin int32) (_r0 int32, _err error) { + C.meos_errno_reset() _cret := C.date_get_bin(C.DateADT(d), duration._inner, C.DateADT(torigin)) - return int32(_cret) + if _err = meosError(); _err != nil { + return + } + return int32(_cret), nil } // DatespanBins wraps MEOS C function datespan_bins. -func DatespanBins(s *Span, duration *Interval, torigin int32, count unsafe.Pointer) *Span { +func DatespanBins(s *Span, duration *Interval, torigin int32, count unsafe.Pointer) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.datespan_bins(s._inner, duration._inner, C.DateADT(torigin), (*C.int)(unsafe.Pointer(count))) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // DatespansetBins wraps MEOS C function datespanset_bins. -func DatespansetBins(ss *SpanSet, duration *Interval, torigin int32, count unsafe.Pointer) *Span { +func DatespansetBins(ss *SpanSet, duration *Interval, torigin int32, count unsafe.Pointer) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.datespanset_bins(ss._inner, duration._inner, C.DateADT(torigin), (*C.int)(unsafe.Pointer(count))) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // FloatGetBin wraps MEOS C function float_get_bin. -func FloatGetBin(value float64, vsize float64, vorigin float64) float64 { +func FloatGetBin(value float64, vsize float64, vorigin float64) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.float_get_bin(C.double(value), C.double(vsize), C.double(vorigin)) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // FloatspanBins wraps MEOS C function floatspan_bins. -func FloatspanBins(s *Span, vsize float64, vorigin float64, count unsafe.Pointer) *Span { +func FloatspanBins(s *Span, vsize float64, vorigin float64, count unsafe.Pointer) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.floatspan_bins(s._inner, C.double(vsize), C.double(vorigin), (*C.int)(unsafe.Pointer(count))) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // FloatspansetBins wraps MEOS C function floatspanset_bins. -func FloatspansetBins(ss *SpanSet, vsize float64, vorigin float64, count unsafe.Pointer) *Span { +func FloatspansetBins(ss *SpanSet, vsize float64, vorigin float64, count unsafe.Pointer) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.floatspanset_bins(ss._inner, C.double(vsize), C.double(vorigin), (*C.int)(unsafe.Pointer(count))) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // IntGetBin wraps MEOS C function int_get_bin. -func IntGetBin(value int, vsize int, vorigin int) int { +func IntGetBin(value int, vsize int, vorigin int) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.int_get_bin(C.int(value), C.int(vsize), C.int(vorigin)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // IntspanBins wraps MEOS C function intspan_bins. -func IntspanBins(s *Span, vsize int, vorigin int, count unsafe.Pointer) *Span { +func IntspanBins(s *Span, vsize int, vorigin int, count unsafe.Pointer) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.intspan_bins(s._inner, C.int(vsize), C.int(vorigin), (*C.int)(unsafe.Pointer(count))) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // IntspansetBins wraps MEOS C function intspanset_bins. -func IntspansetBins(ss *SpanSet, vsize int, vorigin int, count unsafe.Pointer) *Span { +func IntspansetBins(ss *SpanSet, vsize int, vorigin int, count unsafe.Pointer) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.intspanset_bins(ss._inner, C.int(vsize), C.int(vorigin), (*C.int)(unsafe.Pointer(count))) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TimestamptzGetBin wraps MEOS C function timestamptz_get_bin. -func TimestamptzGetBin(t int64, duration *Interval, torigin int64) int64 { +func TimestamptzGetBin(t int64, duration *Interval, torigin int64) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.timestamptz_get_bin(C.TimestampTz(t), duration._inner, C.TimestampTz(torigin)) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // TstzspanBins wraps MEOS C function tstzspan_bins. -func TstzspanBins(s *Span, duration *Interval, origin int64, count unsafe.Pointer) *Span { +func TstzspanBins(s *Span, duration *Interval, origin int64, count unsafe.Pointer) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.tstzspan_bins(s._inner, duration._inner, C.TimestampTz(origin), (*C.int)(unsafe.Pointer(count))) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TstzspansetBins wraps MEOS C function tstzspanset_bins. -func TstzspansetBins(ss *SpanSet, duration *Interval, torigin int64, count unsafe.Pointer) *Span { +func TstzspansetBins(ss *SpanSet, duration *Interval, torigin int64, count unsafe.Pointer) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.tstzspanset_bins(ss._inner, duration._inner, C.TimestampTz(torigin), (*C.int)(unsafe.Pointer(count))) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TBOXAsHexwkb wraps MEOS C function tbox_as_hexwkb. -func TBOXAsHexwkb(box *TBox, variant uint8, size_out unsafe.Pointer) string { +func TBOXAsHexwkb(box *TBox, variant uint8, size_out unsafe.Pointer) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.tbox_as_hexwkb(box._inner, C.uint8_t(variant), (*C.size_t)(unsafe.Pointer(size_out))) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TBOXAsWKB wraps MEOS C function tbox_as_wkb. -func TBOXAsWKB(box *TBox, variant uint8, size_out unsafe.Pointer) unsafe.Pointer { +func TBOXAsWKB(box *TBox, variant uint8, size_out unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tbox_as_wkb(box._inner, C.uint8_t(variant), (*C.size_t)(unsafe.Pointer(size_out))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TBOXFromHexwkb wraps MEOS C function tbox_from_hexwkb. -func TBOXFromHexwkb(hexwkb string) *TBox { +func TBOXFromHexwkb(hexwkb string) (_r0 *TBox, _err error) { _c_hexwkb := C.CString(hexwkb) defer C.free(unsafe.Pointer(_c_hexwkb)) + C.meos_errno_reset() _cret := C.tbox_from_hexwkb(_c_hexwkb) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TBOXFromWKB wraps MEOS C function tbox_from_wkb. -func TBOXFromWKB(wkb unsafe.Pointer, size uint) *TBox { +func TBOXFromWKB(wkb unsafe.Pointer, size uint) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tbox_from_wkb((*C.uint8_t)(unsafe.Pointer(wkb)), C.size_t(size)) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TBOXIn wraps MEOS C function tbox_in. -func TBOXIn(str string) *TBox { +func TBOXIn(str string) (_r0 *TBox, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tbox_in(_c_str) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TBOXOut wraps MEOS C function tbox_out. -func TBOXOut(box *TBox, maxdd int) string { +func TBOXOut(box *TBox, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.tbox_out(box._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // FloatTimestamptzToTBOX wraps MEOS C function float_timestamptz_to_tbox. -func FloatTimestamptzToTBOX(d float64, t int64) *TBox { +func FloatTimestamptzToTBOX(d float64, t int64) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.float_timestamptz_to_tbox(C.double(d), C.TimestampTz(t)) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // FloatTstzspanToTBOX wraps MEOS C function float_tstzspan_to_tbox. -func FloatTstzspanToTBOX(d float64, s *Span) *TBox { +func FloatTstzspanToTBOX(d float64, s *Span) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.float_tstzspan_to_tbox(C.double(d), s._inner) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // IntTimestamptzToTBOX wraps MEOS C function int_timestamptz_to_tbox. -func IntTimestamptzToTBOX(i int, t int64) *TBox { +func IntTimestamptzToTBOX(i int, t int64) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.int_timestamptz_to_tbox(C.int(i), C.TimestampTz(t)) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // BigintTimestamptzToTBOX wraps MEOS C function bigint_timestamptz_to_tbox. -func BigintTimestamptzToTBOX(i int64, t int64) *TBox { +func BigintTimestamptzToTBOX(i int64, t int64) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.bigint_timestamptz_to_tbox(C.int64_t(i), C.TimestampTz(t)) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // IntTstzspanToTBOX wraps MEOS C function int_tstzspan_to_tbox. -func IntTstzspanToTBOX(i int, s *Span) *TBox { +func IntTstzspanToTBOX(i int, s *Span) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.int_tstzspan_to_tbox(C.int(i), s._inner) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // BigintTstzspanToTBOX wraps MEOS C function bigint_tstzspan_to_tbox. -func BigintTstzspanToTBOX(i int64, s *Span) *TBox { +func BigintTstzspanToTBOX(i int64, s *Span) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.bigint_tstzspan_to_tbox(C.int64_t(i), s._inner) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // NumspanTstzspanToTBOX wraps MEOS C function numspan_tstzspan_to_tbox. -func NumspanTstzspanToTBOX(span *Span, s *Span) *TBox { +func NumspanTstzspanToTBOX(span *Span, s *Span) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.numspan_tstzspan_to_tbox(span._inner, s._inner) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // NumspanTimestamptzToTBOX wraps MEOS C function numspan_timestamptz_to_tbox. -func NumspanTimestamptzToTBOX(span *Span, t int64) *TBox { +func NumspanTimestamptzToTBOX(span *Span, t int64) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.numspan_timestamptz_to_tbox(span._inner, C.TimestampTz(t)) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TBOXCopy wraps MEOS C function tbox_copy. -func TBOXCopy(box *TBox) *TBox { +func TBOXCopy(box *TBox) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tbox_copy(box._inner) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TBOXMake wraps MEOS C function tbox_make. -func TBOXMake(s *Span, p *Span) *TBox { +func TBOXMake(s *Span, p *Span) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tbox_make(s._inner, p._inner) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // FloatToTBOX wraps MEOS C function float_to_tbox. -func FloatToTBOX(d float64) *TBox { +func FloatToTBOX(d float64) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.float_to_tbox(C.double(d)) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // IntToTBOX wraps MEOS C function int_to_tbox. -func IntToTBOX(i int) *TBox { +func IntToTBOX(i int) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.int_to_tbox(C.int(i)) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // BigintToTBOX wraps MEOS C function bigint_to_tbox. -func BigintToTBOX(i int64) *TBox { +func BigintToTBOX(i int64) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.bigint_to_tbox(C.int64_t(i)) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // SetToTBOX wraps MEOS C function set_to_tbox. -func SetToTBOX(s *Set) *TBox { +func SetToTBOX(s *Set) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.set_to_tbox(s._inner) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // SpanToTBOX wraps MEOS C function span_to_tbox. -func SpanToTBOX(s *Span) *TBox { +func SpanToTBOX(s *Span) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.span_to_tbox(s._inner) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // SpansetToTBOX wraps MEOS C function spanset_to_tbox. -func SpansetToTBOX(ss *SpanSet) *TBox { +func SpansetToTBOX(ss *SpanSet) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.spanset_to_tbox(ss._inner) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TBOXToIntspan wraps MEOS C function tbox_to_intspan. -func TBOXToIntspan(box *TBox) *Span { +func TBOXToIntspan(box *TBox) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.tbox_to_intspan(box._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TBOXToBigintspan wraps MEOS C function tbox_to_bigintspan. -func TBOXToBigintspan(box *TBox) *Span { +func TBOXToBigintspan(box *TBox) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.tbox_to_bigintspan(box._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TBOXToFloatspan wraps MEOS C function tbox_to_floatspan. -func TBOXToFloatspan(box *TBox) *Span { +func TBOXToFloatspan(box *TBox) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.tbox_to_floatspan(box._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TBOXToTstzspan wraps MEOS C function tbox_to_tstzspan. -func TBOXToTstzspan(box *TBox) *Span { +func TBOXToTstzspan(box *TBox) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.tbox_to_tstzspan(box._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TimestamptzToTBOX wraps MEOS C function timestamptz_to_tbox. -func TimestamptzToTBOX(t int64) *TBox { +func TimestamptzToTBOX(t int64) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.timestamptz_to_tbox(C.TimestampTz(t)) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TBOXHash wraps MEOS C function tbox_hash. -func TBOXHash(box *TBox) uint32 { +func TBOXHash(box *TBox) (_r0 uint32, _err error) { + C.meos_errno_reset() _cret := C.tbox_hash(box._inner) - return uint32(_cret) + if _err = meosError(); _err != nil { + return + } + return uint32(_cret), nil } // TBOXHashExtended wraps MEOS C function tbox_hash_extended. -func TBOXHashExtended(box *TBox, seed uint64) uint64 { +func TBOXHashExtended(box *TBox, seed uint64) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.tbox_hash_extended(box._inner, C.uint64_t(seed)) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // TBOXHast wraps MEOS C function tbox_hast. -func TBOXHast(box *TBox) bool { +func TBOXHast(box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tbox_hast(box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TBOXHasx wraps MEOS C function tbox_hasx. -func TBOXHasx(box *TBox) bool { +func TBOXHasx(box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tbox_hasx(box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TBOXTmax wraps MEOS C function tbox_tmax. -func TBOXTmax(box *TBox) (bool, int64) { +func TBOXTmax(box *TBox) (_r0 bool, _r1 int64, _err error) { var _out_result C.TimestampTz + C.meos_errno_reset() _cret := C.tbox_tmax(box._inner, &_out_result) - return bool(_cret), int64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), int64(_out_result), nil } // TBOXTmaxInc wraps MEOS C function tbox_tmax_inc. -func TBOXTmaxInc(box *TBox) (bool, bool) { +func TBOXTmaxInc(box *TBox) (_r0 bool, _r1 bool, _err error) { var _out_result C.bool + C.meos_errno_reset() _cret := C.tbox_tmax_inc(box._inner, &_out_result) - return bool(_cret), bool(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), bool(_out_result), nil } // TBOXTmin wraps MEOS C function tbox_tmin. -func TBOXTmin(box *TBox) (bool, int64) { +func TBOXTmin(box *TBox) (_r0 bool, _r1 int64, _err error) { var _out_result C.TimestampTz + C.meos_errno_reset() _cret := C.tbox_tmin(box._inner, &_out_result) - return bool(_cret), int64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), int64(_out_result), nil } // TBOXTminInc wraps MEOS C function tbox_tmin_inc. -func TBOXTminInc(box *TBox) (bool, bool) { +func TBOXTminInc(box *TBox) (_r0 bool, _r1 bool, _err error) { var _out_result C.bool + C.meos_errno_reset() _cret := C.tbox_tmin_inc(box._inner, &_out_result) - return bool(_cret), bool(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), bool(_out_result), nil } // TBOXXmax wraps MEOS C function tbox_xmax. -func TBOXXmax(box *TBox) (bool, float64) { +func TBOXXmax(box *TBox) (_r0 bool, _r1 float64, _err error) { var _out_result C.double + C.meos_errno_reset() _cret := C.tbox_xmax(box._inner, &_out_result) - return bool(_cret), float64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), float64(_out_result), nil } // TBOXXmaxInc wraps MEOS C function tbox_xmax_inc. -func TBOXXmaxInc(box *TBox) (bool, bool) { +func TBOXXmaxInc(box *TBox) (_r0 bool, _r1 bool, _err error) { var _out_result C.bool + C.meos_errno_reset() _cret := C.tbox_xmax_inc(box._inner, &_out_result) - return bool(_cret), bool(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), bool(_out_result), nil } // TBOXXmin wraps MEOS C function tbox_xmin. -func TBOXXmin(box *TBox) (bool, float64) { +func TBOXXmin(box *TBox) (_r0 bool, _r1 float64, _err error) { var _out_result C.double + C.meos_errno_reset() _cret := C.tbox_xmin(box._inner, &_out_result) - return bool(_cret), float64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), float64(_out_result), nil } // TBOXXminInc wraps MEOS C function tbox_xmin_inc. -func TBOXXminInc(box *TBox) (bool, bool) { +func TBOXXminInc(box *TBox) (_r0 bool, _r1 bool, _err error) { var _out_result C.bool + C.meos_errno_reset() _cret := C.tbox_xmin_inc(box._inner, &_out_result) - return bool(_cret), bool(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), bool(_out_result), nil } // TboxfloatXmax wraps MEOS C function tboxfloat_xmax. -func TboxfloatXmax(box *TBox) (bool, float64) { +func TboxfloatXmax(box *TBox) (_r0 bool, _r1 float64, _err error) { var _out_result C.double + C.meos_errno_reset() _cret := C.tboxfloat_xmax(box._inner, &_out_result) - return bool(_cret), float64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), float64(_out_result), nil } // TboxfloatXmin wraps MEOS C function tboxfloat_xmin. -func TboxfloatXmin(box *TBox) (bool, float64) { +func TboxfloatXmin(box *TBox) (_r0 bool, _r1 float64, _err error) { var _out_result C.double + C.meos_errno_reset() _cret := C.tboxfloat_xmin(box._inner, &_out_result) - return bool(_cret), float64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), float64(_out_result), nil } // TboxintXmax wraps MEOS C function tboxint_xmax. -func TboxintXmax(box *TBox) (bool, int) { +func TboxintXmax(box *TBox) (_r0 bool, _r1 int, _err error) { var _out_result C.int + C.meos_errno_reset() _cret := C.tboxint_xmax(box._inner, &_out_result) - return bool(_cret), int(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), int(_out_result), nil } // TboxbigintXmax wraps MEOS C function tboxbigint_xmax. -func TboxbigintXmax(box *TBox) (bool, int64) { +func TboxbigintXmax(box *TBox) (_r0 bool, _r1 int64, _err error) { var _out_result C.int64_t + C.meos_errno_reset() _cret := C.tboxbigint_xmax(box._inner, &_out_result) - return bool(_cret), int64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), int64(_out_result), nil } // TboxintXmin wraps MEOS C function tboxint_xmin. -func TboxintXmin(box *TBox) (bool, int) { +func TboxintXmin(box *TBox) (_r0 bool, _r1 int, _err error) { var _out_result C.int + C.meos_errno_reset() _cret := C.tboxint_xmin(box._inner, &_out_result) - return bool(_cret), int(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), int(_out_result), nil } // TboxbigintXmin wraps MEOS C function tboxbigint_xmin. -func TboxbigintXmin(box *TBox) (bool, int64) { +func TboxbigintXmin(box *TBox) (_r0 bool, _r1 int64, _err error) { var _out_result C.int64_t + C.meos_errno_reset() _cret := C.tboxbigint_xmin(box._inner, &_out_result) - return bool(_cret), int64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), int64(_out_result), nil } // TfloatboxExpand wraps MEOS C function tfloatbox_expand. -func TfloatboxExpand(box *TBox, d float64) *TBox { +func TfloatboxExpand(box *TBox, d float64) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tfloatbox_expand(box._inner, C.double(d)) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TintboxExpand wraps MEOS C function tintbox_expand. -func TintboxExpand(box *TBox, i int) *TBox { +func TintboxExpand(box *TBox, i int) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tintbox_expand(box._inner, C.int(i)) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TBOXExpandTime wraps MEOS C function tbox_expand_time. -func TBOXExpandTime(box *TBox, interv *Interval) *TBox { +func TBOXExpandTime(box *TBox, interv *Interval) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tbox_expand_time(box._inner, interv._inner) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TBOXRound wraps MEOS C function tbox_round. -func TBOXRound(box *TBox, maxdd int) *TBox { +func TBOXRound(box *TBox, maxdd int) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tbox_round(box._inner, C.int(maxdd)) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TfloatboxShiftScale wraps MEOS C function tfloatbox_shift_scale. -func TfloatboxShiftScale(box *TBox, shift float64, width float64, hasshift bool, haswidth bool) *TBox { +func TfloatboxShiftScale(box *TBox, shift float64, width float64, hasshift bool, haswidth bool) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tfloatbox_shift_scale(box._inner, C.double(shift), C.double(width), C.bool(hasshift), C.bool(haswidth)) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TintboxShiftScale wraps MEOS C function tintbox_shift_scale. -func TintboxShiftScale(box *TBox, shift int, width int, hasshift bool, haswidth bool) *TBox { +func TintboxShiftScale(box *TBox, shift int, width int, hasshift bool, haswidth bool) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tintbox_shift_scale(box._inner, C.int(shift), C.int(width), C.bool(hasshift), C.bool(haswidth)) - return &TBox{_inner: _cret} + 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) *TBox { +func TBOXShiftScaleTime(box *TBox, shift *Interval, duration *Interval) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tbox_shift_scale_time(box._inner, shift._inner, duration._inner) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TbigintboxExpand wraps MEOS C function tbigintbox_expand. -func TbigintboxExpand(box *TBox, i int64) *TBox { +func TbigintboxExpand(box *TBox, i int64) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tbigintbox_expand(box._inner, C.int64_t(i)) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TbigintboxShiftScale wraps MEOS C function tbigintbox_shift_scale. -func TbigintboxShiftScale(box *TBox, shift int64, width int64, hasshift bool, haswidth bool) *TBox { +func TbigintboxShiftScale(box *TBox, shift int64, width int64, hasshift bool, haswidth bool) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tbigintbox_shift_scale(box._inner, C.int64_t(shift), C.int64_t(width), C.bool(hasshift), C.bool(haswidth)) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // UnionTBOXTBOX wraps MEOS C function union_tbox_tbox. -func UnionTBOXTBOX(box1 *TBox, box2 *TBox, strict bool) *TBox { +func UnionTBOXTBOX(box1 *TBox, box2 *TBox, strict bool) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.gunion_tbox_tbox(box1._inner, box2._inner, C.bool(strict)) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // IntersectionTBOXTBOX wraps MEOS C function intersection_tbox_tbox. -func IntersectionTBOXTBOX(box1 *TBox, box2 *TBox) *TBox { +func IntersectionTBOXTBOX(box1 *TBox, box2 *TBox) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.intersection_tbox_tbox(box1._inner, box2._inner) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // AdjacentTBOXTBOX wraps MEOS C function adjacent_tbox_tbox. -func AdjacentTBOXTBOX(box1 *TBox, box2 *TBox) bool { +func AdjacentTBOXTBOX(box1 *TBox, box2 *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_tbox_tbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedTBOXTBOX wraps MEOS C function contained_tbox_tbox. -func ContainedTBOXTBOX(box1 *TBox, box2 *TBox) bool { +func ContainedTBOXTBOX(box1 *TBox, box2 *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_tbox_tbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsTBOXTBOX wraps MEOS C function contains_tbox_tbox. -func ContainsTBOXTBOX(box1 *TBox, box2 *TBox) bool { +func ContainsTBOXTBOX(box1 *TBox, box2 *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_tbox_tbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverlapsTBOXTBOX wraps MEOS C function overlaps_tbox_tbox. -func OverlapsTBOXTBOX(box1 *TBox, box2 *TBox) bool { +func OverlapsTBOXTBOX(box1 *TBox, box2 *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overlaps_tbox_tbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SameTBOXTBOX wraps MEOS C function same_tbox_tbox. -func SameTBOXTBOX(box1 *TBox, box2 *TBox) bool { +func SameTBOXTBOX(box1 *TBox, box2 *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.same_tbox_tbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterTBOXTBOX wraps MEOS C function after_tbox_tbox. -func AfterTBOXTBOX(box1 *TBox, box2 *TBox) bool { +func AfterTBOXTBOX(box1 *TBox, box2 *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_tbox_tbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeTBOXTBOX wraps MEOS C function before_tbox_tbox. -func BeforeTBOXTBOX(box1 *TBox, box2 *TBox) bool { +func BeforeTBOXTBOX(box1 *TBox, box2 *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_tbox_tbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftTBOXTBOX wraps MEOS C function left_tbox_tbox. -func LeftTBOXTBOX(box1 *TBox, box2 *TBox) bool { +func LeftTBOXTBOX(box1 *TBox, box2 *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_tbox_tbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterTBOXTBOX wraps MEOS C function overafter_tbox_tbox. -func OverafterTBOXTBOX(box1 *TBox, box2 *TBox) bool { +func OverafterTBOXTBOX(box1 *TBox, box2 *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_tbox_tbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeTBOXTBOX wraps MEOS C function overbefore_tbox_tbox. -func OverbeforeTBOXTBOX(box1 *TBox, box2 *TBox) bool { +func OverbeforeTBOXTBOX(box1 *TBox, box2 *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_tbox_tbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftTBOXTBOX wraps MEOS C function overleft_tbox_tbox. -func OverleftTBOXTBOX(box1 *TBox, box2 *TBox) bool { +func OverleftTBOXTBOX(box1 *TBox, box2 *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_tbox_tbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightTBOXTBOX wraps MEOS C function overright_tbox_tbox. -func OverrightTBOXTBOX(box1 *TBox, box2 *TBox) bool { +func OverrightTBOXTBOX(box1 *TBox, box2 *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_tbox_tbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightTBOXTBOX wraps MEOS C function right_tbox_tbox. -func RightTBOXTBOX(box1 *TBox, box2 *TBox) bool { +func RightTBOXTBOX(box1 *TBox, box2 *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_tbox_tbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TBOXCmp wraps MEOS C function tbox_cmp. -func TBOXCmp(box1 *TBox, box2 *TBox) int { +func TBOXCmp(box1 *TBox, box2 *TBox) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.tbox_cmp(box1._inner, box2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TBOXEq wraps MEOS C function tbox_eq. -func TBOXEq(box1 *TBox, box2 *TBox) bool { +func TBOXEq(box1 *TBox, box2 *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tbox_eq(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TBOXGe wraps MEOS C function tbox_ge. -func TBOXGe(box1 *TBox, box2 *TBox) bool { +func TBOXGe(box1 *TBox, box2 *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tbox_ge(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TBOXGt wraps MEOS C function tbox_gt. -func TBOXGt(box1 *TBox, box2 *TBox) bool { +func TBOXGt(box1 *TBox, box2 *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tbox_gt(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TBOXLe wraps MEOS C function tbox_le. -func TBOXLe(box1 *TBox, box2 *TBox) bool { +func TBOXLe(box1 *TBox, box2 *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tbox_le(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TBOXLt wraps MEOS C function tbox_lt. -func TBOXLt(box1 *TBox, box2 *TBox) bool { +func TBOXLt(box1 *TBox, box2 *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tbox_lt(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TBOXNe wraps MEOS C function tbox_ne. -func TBOXNe(box1 *TBox, box2 *TBox) bool { +func TBOXNe(box1 *TBox, box2 *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tbox_ne(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TboolFromMFJSON wraps MEOS C function tbool_from_mfjson. -func TboolFromMFJSON(str string) *Temporal { +func TboolFromMFJSON(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tbool_from_mfjson(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TboolIn wraps MEOS C function tbool_in. -func TboolIn(str string) *Temporal { +func TboolIn(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tbool_in(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TboolOut wraps MEOS C function tbool_out. -func TboolOut(temp *Temporal) string { +func TboolOut(temp *Temporal) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.tbool_out(temp._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TemporalAsHexwkb wraps MEOS C function temporal_as_hexwkb. -func TemporalAsHexwkb(temp *Temporal, variant uint8, size_out unsafe.Pointer) string { +func TemporalAsHexwkb(temp *Temporal, variant uint8, size_out unsafe.Pointer) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.temporal_as_hexwkb(temp._inner, C.uint8_t(variant), (*C.size_t)(unsafe.Pointer(size_out))) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TemporalAsMFJSON wraps MEOS C function temporal_as_mfjson. -func TemporalAsMFJSON(temp *Temporal, with_bbox bool, flags int, precision int, srs string) string { +func TemporalAsMFJSON(temp *Temporal, with_bbox bool, flags int, precision int, srs string) (_r0 string, _err error) { _c_srs := C.CString(srs) defer C.free(unsafe.Pointer(_c_srs)) + C.meos_errno_reset() _cret := C.temporal_as_mfjson(temp._inner, C.bool(with_bbox), C.int(flags), C.int(precision), _c_srs) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TemporalAsWKB wraps MEOS C function temporal_as_wkb. -func TemporalAsWKB(temp *Temporal, variant uint8, size_out unsafe.Pointer) unsafe.Pointer { +func TemporalAsWKB(temp *Temporal, variant uint8, size_out unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.temporal_as_wkb(temp._inner, C.uint8_t(variant), (*C.size_t)(unsafe.Pointer(size_out))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // WKBVariantFromEndian wraps MEOS C function wkb_variant_from_endian. -func WKBVariantFromEndian(endian string) uint8 { +func WKBVariantFromEndian(endian string) (_r0 uint8, _err error) { _c_endian := C.CString(endian) defer C.free(unsafe.Pointer(_c_endian)) + C.meos_errno_reset() _cret := C.wkb_variant_from_endian(_c_endian) - return uint8(_cret) + if _err = meosError(); _err != nil { + return + } + return uint8(_cret), nil } // TemporalFromHexwkb wraps MEOS C function temporal_from_hexwkb. -func TemporalFromHexwkb(hexwkb string) *Temporal { +func TemporalFromHexwkb(hexwkb string) (_r0 *Temporal, _err error) { _c_hexwkb := C.CString(hexwkb) defer C.free(unsafe.Pointer(_c_hexwkb)) + C.meos_errno_reset() _cret := C.temporal_from_hexwkb(_c_hexwkb) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalFromWKB wraps MEOS C function temporal_from_wkb. -func TemporalFromWKB(wkb unsafe.Pointer, size uint) *Temporal { +func TemporalFromWKB(wkb unsafe.Pointer, size uint) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_from_wkb((*C.uint8_t)(unsafe.Pointer(wkb)), C.size_t(size)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TfloatFromMFJSON wraps MEOS C function tfloat_from_mfjson. -func TfloatFromMFJSON(str string) *Temporal { +func TfloatFromMFJSON(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tfloat_from_mfjson(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TfloatIn wraps MEOS C function tfloat_in. -func TfloatIn(str string) *Temporal { +func TfloatIn(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tfloat_in(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TfloatOut wraps MEOS C function tfloat_out. -func TfloatOut(temp *Temporal, maxdd int) string { +func TfloatOut(temp *Temporal, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.tfloat_out(temp._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TintFromMFJSON wraps MEOS C function tint_from_mfjson. -func TintFromMFJSON(str string) *Temporal { +func TintFromMFJSON(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tint_from_mfjson(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TbigintFromMFJSON wraps MEOS C function tbigint_from_mfjson. -func TbigintFromMFJSON(str string) *Temporal { +func TbigintFromMFJSON(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tbigint_from_mfjson(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TintIn wraps MEOS C function tint_in. -func TintIn(str string) *Temporal { +func TintIn(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tint_in(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TbigintIn wraps MEOS C function tbigint_in. -func TbigintIn(str string) *Temporal { +func TbigintIn(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tbigint_in(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TintOut wraps MEOS C function tint_out. -func TintOut(temp *Temporal) string { +func TintOut(temp *Temporal) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.tint_out(temp._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TbigintOut wraps MEOS C function tbigint_out. -func TbigintOut(temp *Temporal) string { +func TbigintOut(temp *Temporal) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.tbigint_out(temp._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TtextFromMFJSON wraps MEOS C function ttext_from_mfjson. -func TtextFromMFJSON(str string) *Temporal { +func TtextFromMFJSON(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.ttext_from_mfjson(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TtextIn wraps MEOS C function ttext_in. -func TtextIn(str string) *Temporal { +func TtextIn(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.ttext_in(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TtextOut wraps MEOS C function ttext_out. -func TtextOut(temp *Temporal) string { +func TtextOut(temp *Temporal) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.ttext_out(temp._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TboolFromBaseTemp wraps MEOS C function tbool_from_base_temp. -func TboolFromBaseTemp(b bool, temp *Temporal) *Temporal { +func TboolFromBaseTemp(b bool, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tbool_from_base_temp(C.bool(b), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TboolinstMake wraps MEOS C function tboolinst_make. -func TboolinstMake(b bool, t int64) *TInstant { +func TboolinstMake(b bool, t int64) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tboolinst_make(C.bool(b), C.TimestampTz(t)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TboolseqFromBaseTstzset wraps MEOS C function tboolseq_from_base_tstzset. -func TboolseqFromBaseTstzset(b bool, s *Set) *TSequence { +func TboolseqFromBaseTstzset(b bool, s *Set) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tboolseq_from_base_tstzset(C.bool(b), s._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TboolseqFromBaseTstzspan wraps MEOS C function tboolseq_from_base_tstzspan. -func TboolseqFromBaseTstzspan(b bool, s *Span) *TSequence { +func TboolseqFromBaseTstzspan(b bool, s *Span) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tboolseq_from_base_tstzspan(C.bool(b), s._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TboolseqsetFromBaseTstzspanset wraps MEOS C function tboolseqset_from_base_tstzspanset. -func TboolseqsetFromBaseTstzspanset(b bool, ss *SpanSet) *TSequenceSet { +func TboolseqsetFromBaseTstzspanset(b bool, ss *SpanSet) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tboolseqset_from_base_tstzspanset(C.bool(b), ss._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TemporalCopy wraps MEOS C function temporal_copy. -func TemporalCopy(temp *Temporal) *Temporal { +func TemporalCopy(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_copy(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TfloatFromBaseTemp wraps MEOS C function tfloat_from_base_temp. -func TfloatFromBaseTemp(d float64, temp *Temporal) *Temporal { +func TfloatFromBaseTemp(d float64, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tfloat_from_base_temp(C.double(d), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TfloatinstMake wraps MEOS C function tfloatinst_make. -func TfloatinstMake(d float64, t int64) *TInstant { +func TfloatinstMake(d float64, t int64) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tfloatinst_make(C.double(d), C.TimestampTz(t)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TfloatseqFromBaseTstzset wraps MEOS C function tfloatseq_from_base_tstzset. -func TfloatseqFromBaseTstzset(d float64, s *Set) *TSequence { +func TfloatseqFromBaseTstzset(d float64, s *Set) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tfloatseq_from_base_tstzset(C.double(d), s._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TfloatseqFromBaseTstzspan wraps MEOS C function tfloatseq_from_base_tstzspan. -func TfloatseqFromBaseTstzspan(d float64, s *Span, interp Interpolation) *TSequence { +func TfloatseqFromBaseTstzspan(d float64, s *Span, interp Interpolation) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tfloatseq_from_base_tstzspan(C.double(d), s._inner, C.interpType(interp)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TfloatseqsetFromBaseTstzspanset wraps MEOS C function tfloatseqset_from_base_tstzspanset. -func TfloatseqsetFromBaseTstzspanset(d float64, ss *SpanSet, interp Interpolation) *TSequenceSet { +func TfloatseqsetFromBaseTstzspanset(d float64, ss *SpanSet, interp Interpolation) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tfloatseqset_from_base_tstzspanset(C.double(d), ss._inner, C.interpType(interp)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TintFromBaseTemp wraps MEOS C function tint_from_base_temp. -func TintFromBaseTemp(i int, temp *Temporal) *Temporal { +func TintFromBaseTemp(i int, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tint_from_base_temp(C.int(i), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TbigintFromBaseTemp wraps MEOS C function tbigint_from_base_temp. -func TbigintFromBaseTemp(i int64, temp *Temporal) *Temporal { +func TbigintFromBaseTemp(i int64, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tbigint_from_base_temp(C.int64_t(i), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TintinstMake wraps MEOS C function tintinst_make. -func TintinstMake(i int, t int64) *TInstant { +func TintinstMake(i int, t int64) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tintinst_make(C.int(i), C.TimestampTz(t)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TbigintinstMake wraps MEOS C function tbigintinst_make. -func TbigintinstMake(i int64, t int64) *TInstant { +func TbigintinstMake(i int64, t int64) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tbigintinst_make(C.int64_t(i), C.TimestampTz(t)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TintseqFromBaseTstzset wraps MEOS C function tintseq_from_base_tstzset. -func TintseqFromBaseTstzset(i int, s *Set) *TSequence { +func TintseqFromBaseTstzset(i int, s *Set) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tintseq_from_base_tstzset(C.int(i), s._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TbigintseqFromBaseTstzset wraps MEOS C function tbigintseq_from_base_tstzset. -func TbigintseqFromBaseTstzset(i int64, s *Set) *TSequence { +func TbigintseqFromBaseTstzset(i int64, s *Set) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tbigintseq_from_base_tstzset(C.int64_t(i), s._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TintseqFromBaseTstzspan wraps MEOS C function tintseq_from_base_tstzspan. -func TintseqFromBaseTstzspan(i int, s *Span) *TSequence { +func TintseqFromBaseTstzspan(i int, s *Span) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tintseq_from_base_tstzspan(C.int(i), s._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TbigintseqFromBaseTstzspan wraps MEOS C function tbigintseq_from_base_tstzspan. -func TbigintseqFromBaseTstzspan(i int64, s *Span) *TSequence { +func TbigintseqFromBaseTstzspan(i int64, s *Span) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tbigintseq_from_base_tstzspan(C.int64_t(i), s._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TintseqsetFromBaseTstzspanset wraps MEOS C function tintseqset_from_base_tstzspanset. -func TintseqsetFromBaseTstzspanset(i int, ss *SpanSet) *TSequenceSet { +func TintseqsetFromBaseTstzspanset(i int, ss *SpanSet) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tintseqset_from_base_tstzspanset(C.int(i), ss._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TbigintseqsetFromBaseTstzspanset wraps MEOS C function tbigintseqset_from_base_tstzspanset. -func TbigintseqsetFromBaseTstzspanset(i int64, ss *SpanSet) *TSequenceSet { +func TbigintseqsetFromBaseTstzspanset(i int64, ss *SpanSet) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tbigintseqset_from_base_tstzspanset(C.int64_t(i), ss._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequenceMake wraps MEOS C function tsequence_make. -func TsequenceMake(instants unsafe.Pointer, count int, lower_inc bool, upper_inc bool, interp Interpolation, normalize bool) *TSequence { +func TsequenceMake(instants unsafe.Pointer, count int, lower_inc bool, upper_inc bool, interp Interpolation, normalize bool) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tsequence_make((**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} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TsequencesetMake wraps MEOS C function tsequenceset_make. -func TsequencesetMake(sequences unsafe.Pointer, count int, normalize bool) *TSequenceSet { +func TsequencesetMake(sequences unsafe.Pointer, count int, normalize bool) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_make((**C.TSequence)(unsafe.Pointer(sequences)), C.int(count), C.bool(normalize)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequencesetMakeGaps wraps MEOS C function tsequenceset_make_gaps. -func TsequencesetMakeGaps(instants unsafe.Pointer, count int, interp Interpolation, maxt *Interval, maxdist float64) *TSequenceSet { +func TsequencesetMakeGaps(instants unsafe.Pointer, count int, interp Interpolation, maxt *Interval, maxdist float64) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_make_gaps((**C.TInstant)(unsafe.Pointer(instants)), C.int(count), C.interpType(interp), maxt._inner, C.double(maxdist)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TtextFromBaseTemp wraps MEOS C function ttext_from_base_temp. -func TtextFromBaseTemp(txt string, temp *Temporal) *Temporal { +func TtextFromBaseTemp(txt string, temp *Temporal) (_r0 *Temporal, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.ttext_from_base_temp(_c_txt, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TtextinstMake wraps MEOS C function ttextinst_make. -func TtextinstMake(txt string, t int64) *TInstant { +func TtextinstMake(txt string, t int64) (_r0 *TInstant, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.ttextinst_make(_c_txt, C.TimestampTz(t)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TtextseqFromBaseTstzset wraps MEOS C function ttextseq_from_base_tstzset. -func TtextseqFromBaseTstzset(txt string, s *Set) *TSequence { +func TtextseqFromBaseTstzset(txt string, s *Set) (_r0 *TSequence, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.ttextseq_from_base_tstzset(_c_txt, s._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TtextseqFromBaseTstzspan wraps MEOS C function ttextseq_from_base_tstzspan. -func TtextseqFromBaseTstzspan(txt string, s *Span) *TSequence { +func TtextseqFromBaseTstzspan(txt string, s *Span) (_r0 *TSequence, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.ttextseq_from_base_tstzspan(_c_txt, s._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TtextseqsetFromBaseTstzspanset wraps MEOS C function ttextseqset_from_base_tstzspanset. -func TtextseqsetFromBaseTstzspanset(txt string, ss *SpanSet) *TSequenceSet { +func TtextseqsetFromBaseTstzspanset(txt string, ss *SpanSet) (_r0 *TSequenceSet, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.ttextseqset_from_base_tstzspanset(_c_txt, ss._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TboolToTint wraps MEOS C function tbool_to_tint. -func TboolToTint(temp *Temporal) *Temporal { +func TboolToTint(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tbool_to_tint(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalToTstzspan wraps MEOS C function temporal_to_tstzspan. -func TemporalToTstzspan(temp *Temporal) *Span { +func TemporalToTstzspan(temp *Temporal) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.temporal_to_tstzspan(temp._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TfloatToTint wraps MEOS C function tfloat_to_tint. -func TfloatToTint(temp *Temporal) *Temporal { +func TfloatToTint(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tfloat_to_tint(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TfloatToTbigint wraps MEOS C function tfloat_to_tbigint. -func TfloatToTbigint(temp *Temporal) *Temporal { +func TfloatToTbigint(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tfloat_to_tbigint(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TintToTfloat wraps MEOS C function tint_to_tfloat. -func TintToTfloat(temp *Temporal) *Temporal { +func TintToTfloat(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tint_to_tfloat(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TintToTbigint wraps MEOS C function tint_to_tbigint. -func TintToTbigint(temp *Temporal) *Temporal { +func TintToTbigint(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tint_to_tbigint(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TbigintToTint wraps MEOS C function tbigint_to_tint. -func TbigintToTint(temp *Temporal) *Temporal { +func TbigintToTint(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tbigint_to_tint(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TbigintToTfloat wraps MEOS C function tbigint_to_tfloat. -func TbigintToTfloat(temp *Temporal) *Temporal { +func TbigintToTfloat(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tbigint_to_tfloat(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnumberToSpan wraps MEOS C function tnumber_to_span. -func TnumberToSpan(temp *Temporal) *Span { +func TnumberToSpan(temp *Temporal) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.tnumber_to_span(temp._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TnumberToTBOX wraps MEOS C function tnumber_to_tbox. -func TnumberToTBOX(temp *Temporal) *TBox { +func TnumberToTBOX(temp *Temporal) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tnumber_to_tbox(temp._inner) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TboolEndValue wraps MEOS C function tbool_end_value. -func TboolEndValue(temp *Temporal) bool { +func TboolEndValue(temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tbool_end_value(temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TboolStartValue wraps MEOS C function tbool_start_value. -func TboolStartValue(temp *Temporal) bool { +func TboolStartValue(temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tbool_start_value(temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TboolValueAtTimestamptz wraps MEOS C function tbool_value_at_timestamptz. -func TboolValueAtTimestamptz(temp *Temporal, t int64, strict bool) (bool, bool) { +func TboolValueAtTimestamptz(temp *Temporal, t int64, strict bool) (_r0 bool, _r1 bool, _err error) { var _out_value C.bool + C.meos_errno_reset() _cret := C.tbool_value_at_timestamptz(temp._inner, C.TimestampTz(t), C.bool(strict), &_out_value) - return bool(_cret), bool(_out_value) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), bool(_out_value), nil } // TboolValueN wraps MEOS C function tbool_value_n. -func TboolValueN(temp *Temporal, n int) (bool, bool) { +func TboolValueN(temp *Temporal, n int) (_r0 bool, _r1 bool, _err error) { var _out_result C.bool + C.meos_errno_reset() _cret := C.tbool_value_n(temp._inner, C.int(n), &_out_result) - return bool(_cret), bool(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), bool(_out_result), nil } // TboolValues wraps MEOS C function tbool_values. -func TboolValues(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TboolValues(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tbool_values(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TemporalDuration wraps MEOS C function temporal_duration. -func TemporalDuration(temp *Temporal, boundspan bool) *Interval { +func TemporalDuration(temp *Temporal, boundspan bool) (_r0 *Interval, _err error) { + C.meos_errno_reset() _cret := C.temporal_duration(temp._inner, C.bool(boundspan)) - return &Interval{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Interval{_inner: _cret}, nil } // TemporalEndInstant wraps MEOS C function temporal_end_instant. -func TemporalEndInstant(temp *Temporal) *TInstant { +func TemporalEndInstant(temp *Temporal) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.temporal_end_instant(temp._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TemporalEndSequence wraps MEOS C function temporal_end_sequence. -func TemporalEndSequence(temp *Temporal) *TSequence { +func TemporalEndSequence(temp *Temporal) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.temporal_end_sequence(temp._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TemporalEndTimestamptz wraps MEOS C function temporal_end_timestamptz. -func TemporalEndTimestamptz(temp *Temporal) int64 { +func TemporalEndTimestamptz(temp *Temporal) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.temporal_end_timestamptz(temp._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // TemporalHash wraps MEOS C function temporal_hash. -func TemporalHash(temp *Temporal) uint32 { +func TemporalHash(temp *Temporal) (_r0 uint32, _err error) { + C.meos_errno_reset() _cret := C.temporal_hash(temp._inner) - return uint32(_cret) + if _err = meosError(); _err != nil { + return + } + return uint32(_cret), nil } // TemporalHashExtended wraps MEOS C function temporal_hash_extended. -func TemporalHashExtended(temp *Temporal, seed uint64) uint64 { +func TemporalHashExtended(temp *Temporal, seed uint64) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.temporal_hash_extended(temp._inner, C.uint64_t(seed)) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // TemporalInstantN wraps MEOS C function temporal_instant_n. -func TemporalInstantN(temp *Temporal, n int) *TInstant { +func TemporalInstantN(temp *Temporal, n int) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.temporal_instant_n(temp._inner, C.int(n)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TemporalInstants wraps MEOS C function temporal_instants. -func TemporalInstants(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TemporalInstants(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.temporal_instants(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TemporalInterp wraps MEOS C function temporal_interp. -func TemporalInterp(temp *Temporal) string { +func TemporalInterp(temp *Temporal) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.temporal_interp(temp._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TemporalLowerInc wraps MEOS C function temporal_lower_inc. -func TemporalLowerInc(temp *Temporal) bool { +func TemporalLowerInc(temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.temporal_lower_inc(temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TemporalMaxInstant wraps MEOS C function temporal_max_instant. -func TemporalMaxInstant(temp *Temporal) *TInstant { +func TemporalMaxInstant(temp *Temporal) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.temporal_max_instant(temp._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TemporalMinInstant wraps MEOS C function temporal_min_instant. -func TemporalMinInstant(temp *Temporal) *TInstant { +func TemporalMinInstant(temp *Temporal) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.temporal_min_instant(temp._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TemporalNumInstants wraps MEOS C function temporal_num_instants. -func TemporalNumInstants(temp *Temporal) int { +func TemporalNumInstants(temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.temporal_num_instants(temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TemporalNumSequences wraps MEOS C function temporal_num_sequences. -func TemporalNumSequences(temp *Temporal) int { +func TemporalNumSequences(temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.temporal_num_sequences(temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TemporalNumTimestamps wraps MEOS C function temporal_num_timestamps. -func TemporalNumTimestamps(temp *Temporal) int { +func TemporalNumTimestamps(temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.temporal_num_timestamps(temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TemporalSegmDuration wraps MEOS C function temporal_segm_duration. -func TemporalSegmDuration(temp *Temporal, duration *Interval, atleast bool, strict bool) *TSequenceSet { +func TemporalSegmDuration(temp *Temporal, duration *Interval, atleast bool, strict bool) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.temporal_segm_duration(temp._inner, duration._inner, C.bool(atleast), C.bool(strict)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TemporalSegments wraps MEOS C function temporal_segments. -func TemporalSegments(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TemporalSegments(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.temporal_segments(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TemporalSequenceN wraps MEOS C function temporal_sequence_n. -func TemporalSequenceN(temp *Temporal, i int) *TSequence { +func TemporalSequenceN(temp *Temporal, i int) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.temporal_sequence_n(temp._inner, C.int(i)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TemporalSequences wraps MEOS C function temporal_sequences. -func TemporalSequences(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TemporalSequences(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.temporal_sequences(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TemporalStartInstant wraps MEOS C function temporal_start_instant. -func TemporalStartInstant(temp *Temporal) *TInstant { +func TemporalStartInstant(temp *Temporal) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.temporal_start_instant(temp._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TemporalStartSequence wraps MEOS C function temporal_start_sequence. -func TemporalStartSequence(temp *Temporal) *TSequence { +func TemporalStartSequence(temp *Temporal) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.temporal_start_sequence(temp._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TemporalStartTimestamptz wraps MEOS C function temporal_start_timestamptz. -func TemporalStartTimestamptz(temp *Temporal) int64 { +func TemporalStartTimestamptz(temp *Temporal) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.temporal_start_timestamptz(temp._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // TemporalStops wraps MEOS C function temporal_stops. -func TemporalStops(temp *Temporal, maxdist float64, minduration *Interval) *TSequenceSet { +func TemporalStops(temp *Temporal, maxdist float64, minduration *Interval) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.temporal_stops(temp._inner, C.double(maxdist), minduration._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TemporalSubtype wraps MEOS C function temporal_subtype. -func TemporalSubtype(temp *Temporal) string { +func TemporalSubtype(temp *Temporal) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.temporal_subtype(temp._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TemporalBasetypeName wraps MEOS C function temporal_basetype_name. -func TemporalBasetypeName(temp *Temporal) string { +func TemporalBasetypeName(temp *Temporal) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.temporal_basetype_name(temp._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TemporalTime wraps MEOS C function temporal_time. -func TemporalTime(temp *Temporal) *SpanSet { +func TemporalTime(temp *Temporal) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.temporal_time(temp._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // TemporalTimestamps wraps MEOS C function temporal_timestamps. -func TemporalTimestamps(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TemporalTimestamps(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.temporal_timestamps(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TemporalTimestamptzN wraps MEOS C function temporal_timestamptz_n. -func TemporalTimestamptzN(temp *Temporal, n int) (bool, int64) { +func TemporalTimestamptzN(temp *Temporal, n int) (_r0 bool, _r1 int64, _err error) { var _out_result C.TimestampTz + C.meos_errno_reset() _cret := C.temporal_timestamptz_n(temp._inner, C.int(n), &_out_result) - return bool(_cret), int64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), int64(_out_result), nil } // TemporalUpperInc wraps MEOS C function temporal_upper_inc. -func TemporalUpperInc(temp *Temporal) bool { +func TemporalUpperInc(temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.temporal_upper_inc(temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TfloatEndValue wraps MEOS C function tfloat_end_value. -func TfloatEndValue(temp *Temporal) float64 { +func TfloatEndValue(temp *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.tfloat_end_value(temp._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TfloatMinValue wraps MEOS C function tfloat_min_value. -func TfloatMinValue(temp *Temporal) float64 { +func TfloatMinValue(temp *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.tfloat_min_value(temp._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TfloatMaxValue wraps MEOS C function tfloat_max_value. -func TfloatMaxValue(temp *Temporal) float64 { +func TfloatMaxValue(temp *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.tfloat_max_value(temp._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TfloatStartValue wraps MEOS C function tfloat_start_value. -func TfloatStartValue(temp *Temporal) float64 { +func TfloatStartValue(temp *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.tfloat_start_value(temp._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TfloatValueAtTimestamptz wraps MEOS C function tfloat_value_at_timestamptz. -func TfloatValueAtTimestamptz(temp *Temporal, t int64, strict bool) (bool, float64) { +func TfloatValueAtTimestamptz(temp *Temporal, t int64, strict bool) (_r0 bool, _r1 float64, _err error) { var _out_value C.double + C.meos_errno_reset() _cret := C.tfloat_value_at_timestamptz(temp._inner, C.TimestampTz(t), C.bool(strict), &_out_value) - return bool(_cret), float64(_out_value) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), float64(_out_value), nil } // TfloatValueN wraps MEOS C function tfloat_value_n. -func TfloatValueN(temp *Temporal, n int) (bool, float64) { +func TfloatValueN(temp *Temporal, n int) (_r0 bool, _r1 float64, _err error) { var _out_result C.double + C.meos_errno_reset() _cret := C.tfloat_value_n(temp._inner, C.int(n), &_out_result) - return bool(_cret), float64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), float64(_out_result), nil } // TfloatValues wraps MEOS C function tfloat_values. -func TfloatValues(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TfloatValues(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tfloat_values(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TintEndValue wraps MEOS C function tint_end_value. -func TintEndValue(temp *Temporal) int { +func TintEndValue(temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.tint_end_value(temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TbigintEndValue wraps MEOS C function tbigint_end_value. -func TbigintEndValue(temp *Temporal) int64 { +func TbigintEndValue(temp *Temporal) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.tbigint_end_value(temp._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // TintMaxValue wraps MEOS C function tint_max_value. -func TintMaxValue(temp *Temporal) int { +func TintMaxValue(temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.tint_max_value(temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TbigintMaxValue wraps MEOS C function tbigint_max_value. -func TbigintMaxValue(temp *Temporal) int64 { +func TbigintMaxValue(temp *Temporal) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.tbigint_max_value(temp._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // TintMinValue wraps MEOS C function tint_min_value. -func TintMinValue(temp *Temporal) int { +func TintMinValue(temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.tint_min_value(temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TbigintMinValue wraps MEOS C function tbigint_min_value. -func TbigintMinValue(temp *Temporal) int64 { +func TbigintMinValue(temp *Temporal) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.tbigint_min_value(temp._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // TintStartValue wraps MEOS C function tint_start_value. -func TintStartValue(temp *Temporal) int { +func TintStartValue(temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.tint_start_value(temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TbigintStartValue wraps MEOS C function tbigint_start_value. -func TbigintStartValue(temp *Temporal) int64 { +func TbigintStartValue(temp *Temporal) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.tbigint_start_value(temp._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // TbigintValueAtTimestamptz wraps MEOS C function tbigint_value_at_timestamptz. -func TbigintValueAtTimestamptz(temp *Temporal, t int64, strict bool) (bool, int64) { +func TbigintValueAtTimestamptz(temp *Temporal, t int64, strict bool) (_r0 bool, _r1 int64, _err error) { var _out_value C.int64_t + C.meos_errno_reset() _cret := C.tbigint_value_at_timestamptz(temp._inner, C.TimestampTz(t), C.bool(strict), &_out_value) - return bool(_cret), int64(_out_value) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), int64(_out_value), nil } // TintValueAtTimestamptz wraps MEOS C function tint_value_at_timestamptz. -func TintValueAtTimestamptz(temp *Temporal, t int64, strict bool) (bool, int) { +func TintValueAtTimestamptz(temp *Temporal, t int64, strict bool) (_r0 bool, _r1 int, _err error) { var _out_value C.int + C.meos_errno_reset() _cret := C.tint_value_at_timestamptz(temp._inner, C.TimestampTz(t), C.bool(strict), &_out_value) - return bool(_cret), int(_out_value) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), int(_out_value), nil } // TintValueN wraps MEOS C function tint_value_n. -func TintValueN(temp *Temporal, n int) (bool, int) { +func TintValueN(temp *Temporal, n int) (_r0 bool, _r1 int, _err error) { var _out_result C.int + C.meos_errno_reset() _cret := C.tint_value_n(temp._inner, C.int(n), &_out_result) - return bool(_cret), int(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), int(_out_result), nil } // TbigintValueN wraps MEOS C function tbigint_value_n. -func TbigintValueN(temp *Temporal, n int64) (bool, int64) { +func TbigintValueN(temp *Temporal, n int64) (_r0 bool, _r1 int64, _err error) { var _out_result C.int64_t + C.meos_errno_reset() _cret := C.tbigint_value_n(temp._inner, C.int64_t(n), &_out_result) - return bool(_cret), int64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), int64(_out_result), nil } // TintValues wraps MEOS C function tint_values. -func TintValues(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TintValues(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tint_values(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TbigintValues wraps MEOS C function tbigint_values. -func TbigintValues(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TbigintValues(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tbigint_values(temp._inner, (*C.int32)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TnumberAvgValue wraps MEOS C function tnumber_avg_value. -func TnumberAvgValue(temp *Temporal) float64 { +func TnumberAvgValue(temp *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.tnumber_avg_value(temp._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TnumberIntegral wraps MEOS C function tnumber_integral. -func TnumberIntegral(temp *Temporal) float64 { +func TnumberIntegral(temp *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.tnumber_integral(temp._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TnumberTwavg wraps MEOS C function tnumber_twavg. -func TnumberTwavg(temp *Temporal) float64 { +func TnumberTwavg(temp *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.tnumber_twavg(temp._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TnumberValuespans wraps MEOS C function tnumber_valuespans. -func TnumberValuespans(temp *Temporal) *SpanSet { +func TnumberValuespans(temp *Temporal) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.tnumber_valuespans(temp._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // TtextEndValue wraps MEOS C function ttext_end_value. -func TtextEndValue(temp *Temporal) string { +func TtextEndValue(temp *Temporal) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.ttext_end_value(temp._inner) - return C.GoString(C.text_to_cstring(_cret)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(C.text_to_cstring(_cret)), nil } // TtextMaxValue wraps MEOS C function ttext_max_value. -func TtextMaxValue(temp *Temporal) string { +func TtextMaxValue(temp *Temporal) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.ttext_max_value(temp._inner) - return C.GoString(C.text_to_cstring(_cret)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(C.text_to_cstring(_cret)), nil } // TtextMinValue wraps MEOS C function ttext_min_value. -func TtextMinValue(temp *Temporal) string { +func TtextMinValue(temp *Temporal) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.ttext_min_value(temp._inner) - return C.GoString(C.text_to_cstring(_cret)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(C.text_to_cstring(_cret)), nil } // TtextStartValue wraps MEOS C function ttext_start_value. -func TtextStartValue(temp *Temporal) string { +func TtextStartValue(temp *Temporal) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.ttext_start_value(temp._inner) - return C.GoString(C.text_to_cstring(_cret)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(C.text_to_cstring(_cret)), nil } // TtextValueAtTimestamptz wraps MEOS C function ttext_value_at_timestamptz. -func TtextValueAtTimestamptz(temp *Temporal, t int64, strict bool) (bool, string) { +func TtextValueAtTimestamptz(temp *Temporal, t int64, strict bool) (_r0 bool, _r1 string, _err error) { var _out_value *C.text + C.meos_errno_reset() _cret := C.ttext_value_at_timestamptz(temp._inner, C.TimestampTz(t), C.bool(strict), &_out_value) - return bool(_cret), C.GoString(C.text_to_cstring(_out_value)) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), C.GoString(C.text_to_cstring(_out_value)), nil } // TtextValueN wraps MEOS C function ttext_value_n. -func TtextValueN(temp *Temporal, n int) (bool, string) { +func TtextValueN(temp *Temporal, n int) (_r0 bool, _r1 string, _err error) { var _out_result *C.text + C.meos_errno_reset() _cret := C.ttext_value_n(temp._inner, C.int(n), &_out_result) - return bool(_cret), C.GoString(C.text_to_cstring(_out_result)) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), C.GoString(C.text_to_cstring(_out_result)), nil } // TtextValues wraps MEOS C function ttext_values. -func TtextValues(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TtextValues(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.ttext_values(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // FloatDegrees wraps MEOS C function float_degrees. -func FloatDegrees(value float64, normalize bool) float64 { +func FloatDegrees(value float64, normalize bool) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.float_degrees(C.double(value), C.bool(normalize)) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TemparrRound wraps MEOS C function temparr_round. -func TemparrRound(temp unsafe.Pointer, count int, maxdd int) unsafe.Pointer { +func TemparrRound(temp unsafe.Pointer, count int, maxdd int) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.temparr_round((**C.Temporal)(unsafe.Pointer(temp)), C.int(count), C.int(maxdd)) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TemporalRound wraps MEOS C function temporal_round. -func TemporalRound(temp *Temporal, maxdd int) *Temporal { +func TemporalRound(temp *Temporal, maxdd int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_round(temp._inner, C.int(maxdd)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalScaleTime wraps MEOS C function temporal_scale_time. -func TemporalScaleTime(temp *Temporal, duration *Interval) *Temporal { +func TemporalScaleTime(temp *Temporal, duration *Interval) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_scale_time(temp._inner, duration._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalSetInterp wraps MEOS C function temporal_set_interp. -func TemporalSetInterp(temp *Temporal, interp Interpolation) *Temporal { +func TemporalSetInterp(temp *Temporal, interp Interpolation) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_set_interp(temp._inner, C.interpType(interp)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalShiftScaleTime wraps MEOS C function temporal_shift_scale_time. -func TemporalShiftScaleTime(temp *Temporal, shift *Interval, duration *Interval) *Temporal { +func TemporalShiftScaleTime(temp *Temporal, shift *Interval, duration *Interval) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_shift_scale_time(temp._inner, shift._inner, duration._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalShiftTime wraps MEOS C function temporal_shift_time. -func TemporalShiftTime(temp *Temporal, shift *Interval) *Temporal { +func TemporalShiftTime(temp *Temporal, shift *Interval) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_shift_time(temp._inner, shift._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalAsTinstant wraps MEOS C function temporal_as_tinstant. -func TemporalAsTinstant(temp *Temporal) *TInstant { +func TemporalAsTinstant(temp *Temporal) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.temporal_as_tinstant(temp._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TemporalAsTsequence wraps MEOS C function temporal_as_tsequence. -func TemporalAsTsequence(temp *Temporal, interp Interpolation) *TSequence { +func TemporalAsTsequence(temp *Temporal, interp Interpolation) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.temporal_as_tsequence(temp._inner, C.interpType(interp)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TemporalAsTsequenceset wraps MEOS C function temporal_as_tsequenceset. -func TemporalAsTsequenceset(temp *Temporal, interp Interpolation) *TSequenceSet { +func TemporalAsTsequenceset(temp *Temporal, interp Interpolation) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.temporal_as_tsequenceset(temp._inner, C.interpType(interp)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TfloatCeil wraps MEOS C function tfloat_ceil. -func TfloatCeil(temp *Temporal) *Temporal { +func TfloatCeil(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tfloat_ceil(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TfloatDegrees wraps MEOS C function tfloat_degrees. -func TfloatDegrees(temp *Temporal, normalize bool) *Temporal { +func TfloatDegrees(temp *Temporal, normalize bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tfloat_degrees(temp._inner, C.bool(normalize)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TfloatFloor wraps MEOS C function tfloat_floor. -func TfloatFloor(temp *Temporal) *Temporal { +func TfloatFloor(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tfloat_floor(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TfloatRadians wraps MEOS C function tfloat_radians. -func TfloatRadians(temp *Temporal) *Temporal { +func TfloatRadians(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tfloat_radians(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TfloatScaleValue wraps MEOS C function tfloat_scale_value. -func TfloatScaleValue(temp *Temporal, width float64) *Temporal { +func TfloatScaleValue(temp *Temporal, width float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tfloat_scale_value(temp._inner, C.double(width)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TfloatShiftScaleValue wraps MEOS C function tfloat_shift_scale_value. -func TfloatShiftScaleValue(temp *Temporal, shift float64, width float64) *Temporal { +func TfloatShiftScaleValue(temp *Temporal, shift float64, width float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tfloat_shift_scale_value(temp._inner, C.double(shift), C.double(width)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TfloatShiftValue wraps MEOS C function tfloat_shift_value. -func TfloatShiftValue(temp *Temporal, shift float64) *Temporal { +func TfloatShiftValue(temp *Temporal, shift float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tfloat_shift_value(temp._inner, C.double(shift)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TintScaleValue wraps MEOS C function tint_scale_value. -func TintScaleValue(temp *Temporal, width int) *Temporal { +func TintScaleValue(temp *Temporal, width int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tint_scale_value(temp._inner, C.int(width)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TbigintScaleValue wraps MEOS C function tbigint_scale_value. -func TbigintScaleValue(temp *Temporal, width int64) *Temporal { +func TbigintScaleValue(temp *Temporal, width int64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tbigint_scale_value(temp._inner, C.int64_t(width)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TintShiftScaleValue wraps MEOS C function tint_shift_scale_value. -func TintShiftScaleValue(temp *Temporal, shift int, width int) *Temporal { +func TintShiftScaleValue(temp *Temporal, shift int, width int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tint_shift_scale_value(temp._inner, C.int(shift), C.int(width)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TbigintShiftScaleValue wraps MEOS C function tbigint_shift_scale_value. -func TbigintShiftScaleValue(temp *Temporal, shift int64, width int64) *Temporal { +func TbigintShiftScaleValue(temp *Temporal, shift int64, width int64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tbigint_shift_scale_value(temp._inner, C.int64_t(shift), C.int64_t(width)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TintShiftValue wraps MEOS C function tint_shift_value. -func TintShiftValue(temp *Temporal, shift int) *Temporal { +func TintShiftValue(temp *Temporal, shift int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tint_shift_value(temp._inner, C.int(shift)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TbigintShiftValue wraps MEOS C function tbigint_shift_value. -func TbigintShiftValue(temp *Temporal, shift int64) *Temporal { +func TbigintShiftValue(temp *Temporal, shift int64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tbigint_shift_value(temp._inner, C.int64_t(shift)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalAppendTinstant wraps MEOS C function temporal_append_tinstant. -func TemporalAppendTinstant(temp *Temporal, inst *TInstant, interp Interpolation, maxdist float64, maxt *Interval, expand bool) *Temporal { +func TemporalAppendTinstant(temp *Temporal, inst *TInstant, interp Interpolation, maxdist float64, maxt *Interval, expand bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_append_tinstant(temp._inner, inst._inner, C.interpType(interp), C.double(maxdist), maxt._inner, C.bool(expand)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalAppendTsequence wraps MEOS C function temporal_append_tsequence. -func TemporalAppendTsequence(temp *Temporal, seq *TSequence, expand bool) *Temporal { +func TemporalAppendTsequence(temp *Temporal, seq *TSequence, expand bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_append_tsequence(temp._inner, seq._inner, C.bool(expand)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalDeleteTimestamptz wraps MEOS C function temporal_delete_timestamptz. -func TemporalDeleteTimestamptz(temp *Temporal, t int64, connect bool) *Temporal { +func TemporalDeleteTimestamptz(temp *Temporal, t int64, connect bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_delete_timestamptz(temp._inner, C.TimestampTz(t), C.bool(connect)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalDeleteTstzset wraps MEOS C function temporal_delete_tstzset. -func TemporalDeleteTstzset(temp *Temporal, s *Set, connect bool) *Temporal { +func TemporalDeleteTstzset(temp *Temporal, s *Set, connect bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_delete_tstzset(temp._inner, s._inner, C.bool(connect)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalDeleteTstzspan wraps MEOS C function temporal_delete_tstzspan. -func TemporalDeleteTstzspan(temp *Temporal, s *Span, connect bool) *Temporal { +func TemporalDeleteTstzspan(temp *Temporal, s *Span, connect bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_delete_tstzspan(temp._inner, s._inner, C.bool(connect)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalDeleteTstzspanset wraps MEOS C function temporal_delete_tstzspanset. -func TemporalDeleteTstzspanset(temp *Temporal, ss *SpanSet, connect bool) *Temporal { +func TemporalDeleteTstzspanset(temp *Temporal, ss *SpanSet, connect bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_delete_tstzspanset(temp._inner, ss._inner, C.bool(connect)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalInsert wraps MEOS C function temporal_insert. -func TemporalInsert(temp1 *Temporal, temp2 *Temporal, connect bool) *Temporal { +func TemporalInsert(temp1 *Temporal, temp2 *Temporal, connect bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_insert(temp1._inner, temp2._inner, C.bool(connect)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalMerge wraps MEOS C function temporal_merge. -func TemporalMerge(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TemporalMerge(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_merge(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalMergeArray wraps MEOS C function temporal_merge_array. -func TemporalMergeArray(temparr unsafe.Pointer, count int) *Temporal { +func TemporalMergeArray(temparr unsafe.Pointer, count int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_merge_array((**C.Temporal)(unsafe.Pointer(temparr)), C.int(count)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalUpdate wraps MEOS C function temporal_update. -func TemporalUpdate(temp1 *Temporal, temp2 *Temporal, connect bool) *Temporal { +func TemporalUpdate(temp1 *Temporal, temp2 *Temporal, connect bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_update(temp1._inner, temp2._inner, C.bool(connect)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TboolAtValue wraps MEOS C function tbool_at_value. -func TboolAtValue(temp *Temporal, b bool) *Temporal { +func TboolAtValue(temp *Temporal, b bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tbool_at_value(temp._inner, C.bool(b)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TboolMinusValue wraps MEOS C function tbool_minus_value. -func TboolMinusValue(temp *Temporal, b bool) *Temporal { +func TboolMinusValue(temp *Temporal, b bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tbool_minus_value(temp._inner, C.bool(b)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalAfterTimestamptz wraps MEOS C function temporal_after_timestamptz. -func TemporalAfterTimestamptz(temp *Temporal, t int64, strict bool) *Temporal { +func TemporalAfterTimestamptz(temp *Temporal, t int64, strict bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_after_timestamptz(temp._inner, C.TimestampTz(t), C.bool(strict)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalAtMax wraps MEOS C function temporal_at_max. -func TemporalAtMax(temp *Temporal) *Temporal { +func TemporalAtMax(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_at_max(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalAtMin wraps MEOS C function temporal_at_min. -func TemporalAtMin(temp *Temporal) *Temporal { +func TemporalAtMin(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_at_min(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalAtTimestamptz wraps MEOS C function temporal_at_timestamptz. -func TemporalAtTimestamptz(temp *Temporal, t int64) *Temporal { +func TemporalAtTimestamptz(temp *Temporal, t int64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_at_timestamptz(temp._inner, C.TimestampTz(t)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalAtTstzset wraps MEOS C function temporal_at_tstzset. -func TemporalAtTstzset(temp *Temporal, s *Set) *Temporal { +func TemporalAtTstzset(temp *Temporal, s *Set) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_at_tstzset(temp._inner, s._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalAtTstzspan wraps MEOS C function temporal_at_tstzspan. -func TemporalAtTstzspan(temp *Temporal, s *Span) *Temporal { +func TemporalAtTstzspan(temp *Temporal, s *Span) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_at_tstzspan(temp._inner, s._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalAtTstzspanset wraps MEOS C function temporal_at_tstzspanset. -func TemporalAtTstzspanset(temp *Temporal, ss *SpanSet) *Temporal { +func TemporalAtTstzspanset(temp *Temporal, ss *SpanSet) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_at_tstzspanset(temp._inner, ss._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalAtValues wraps MEOS C function temporal_at_values. -func TemporalAtValues(temp *Temporal, set *Set) *Temporal { +func TemporalAtValues(temp *Temporal, set *Set) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_at_values(temp._inner, set._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalBeforeTimestamptz wraps MEOS C function temporal_before_timestamptz. -func TemporalBeforeTimestamptz(temp *Temporal, t int64, strict bool) *Temporal { +func TemporalBeforeTimestamptz(temp *Temporal, t int64, strict bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_before_timestamptz(temp._inner, C.TimestampTz(t), C.bool(strict)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalMinusMax wraps MEOS C function temporal_minus_max. -func TemporalMinusMax(temp *Temporal) *Temporal { +func TemporalMinusMax(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_minus_max(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalMinusMin wraps MEOS C function temporal_minus_min. -func TemporalMinusMin(temp *Temporal) *Temporal { +func TemporalMinusMin(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_minus_min(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalMinusTimestamptz wraps MEOS C function temporal_minus_timestamptz. -func TemporalMinusTimestamptz(temp *Temporal, t int64) *Temporal { +func TemporalMinusTimestamptz(temp *Temporal, t int64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_minus_timestamptz(temp._inner, C.TimestampTz(t)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalMinusTstzset wraps MEOS C function temporal_minus_tstzset. -func TemporalMinusTstzset(temp *Temporal, s *Set) *Temporal { +func TemporalMinusTstzset(temp *Temporal, s *Set) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_minus_tstzset(temp._inner, s._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalMinusTstzspan wraps MEOS C function temporal_minus_tstzspan. -func TemporalMinusTstzspan(temp *Temporal, s *Span) *Temporal { +func TemporalMinusTstzspan(temp *Temporal, s *Span) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_minus_tstzspan(temp._inner, s._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalMinusTstzspanset wraps MEOS C function temporal_minus_tstzspanset. -func TemporalMinusTstzspanset(temp *Temporal, ss *SpanSet) *Temporal { +func TemporalMinusTstzspanset(temp *Temporal, ss *SpanSet) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_minus_tstzspanset(temp._inner, ss._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalMinusValues wraps MEOS C function temporal_minus_values. -func TemporalMinusValues(temp *Temporal, set *Set) *Temporal { +func TemporalMinusValues(temp *Temporal, set *Set) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_minus_values(temp._inner, set._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TfloatAtValue wraps MEOS C function tfloat_at_value. -func TfloatAtValue(temp *Temporal, d float64) *Temporal { +func TfloatAtValue(temp *Temporal, d float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tfloat_at_value(temp._inner, C.double(d)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TfloatMinusValue wraps MEOS C function tfloat_minus_value. -func TfloatMinusValue(temp *Temporal, d float64) *Temporal { +func TfloatMinusValue(temp *Temporal, d float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tfloat_minus_value(temp._inner, C.double(d)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TintAtValue wraps MEOS C function tint_at_value. -func TintAtValue(temp *Temporal, i int) *Temporal { +func TintAtValue(temp *Temporal, i int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tint_at_value(temp._inner, C.int(i)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TintMinusValue wraps MEOS C function tint_minus_value. -func TintMinusValue(temp *Temporal, i int) *Temporal { +func TintMinusValue(temp *Temporal, i int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tint_minus_value(temp._inner, C.int(i)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnumberAtSpan wraps MEOS C function tnumber_at_span. -func TnumberAtSpan(temp *Temporal, span *Span) *Temporal { +func TnumberAtSpan(temp *Temporal, span *Span) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnumber_at_span(temp._inner, span._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnumberAtSpanset wraps MEOS C function tnumber_at_spanset. -func TnumberAtSpanset(temp *Temporal, ss *SpanSet) *Temporal { +func TnumberAtSpanset(temp *Temporal, ss *SpanSet) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnumber_at_spanset(temp._inner, ss._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnumberAtTBOX wraps MEOS C function tnumber_at_tbox. -func TnumberAtTBOX(temp *Temporal, box *TBox) *Temporal { +func TnumberAtTBOX(temp *Temporal, box *TBox) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnumber_at_tbox(temp._inner, box._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnumberMinusSpan wraps MEOS C function tnumber_minus_span. -func TnumberMinusSpan(temp *Temporal, span *Span) *Temporal { +func TnumberMinusSpan(temp *Temporal, span *Span) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnumber_minus_span(temp._inner, span._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnumberMinusSpanset wraps MEOS C function tnumber_minus_spanset. -func TnumberMinusSpanset(temp *Temporal, ss *SpanSet) *Temporal { +func TnumberMinusSpanset(temp *Temporal, ss *SpanSet) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnumber_minus_spanset(temp._inner, ss._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnumberMinusTBOX wraps MEOS C function tnumber_minus_tbox. -func TnumberMinusTBOX(temp *Temporal, box *TBox) *Temporal { +func TnumberMinusTBOX(temp *Temporal, box *TBox) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnumber_minus_tbox(temp._inner, box._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TtextAtValue wraps MEOS C function ttext_at_value. -func TtextAtValue(temp *Temporal, txt string) *Temporal { +func TtextAtValue(temp *Temporal, txt string) (_r0 *Temporal, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.ttext_at_value(temp._inner, _c_txt) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TtextMinusValue wraps MEOS C function ttext_minus_value. -func TtextMinusValue(temp *Temporal, txt string) *Temporal { +func TtextMinusValue(temp *Temporal, txt string) (_r0 *Temporal, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.ttext_minus_value(temp._inner, _c_txt) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalCmp wraps MEOS C function temporal_cmp. -func TemporalCmp(temp1 *Temporal, temp2 *Temporal) int { +func TemporalCmp(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.temporal_cmp(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TemporalEq wraps MEOS C function temporal_eq. -func TemporalEq(temp1 *Temporal, temp2 *Temporal) bool { +func TemporalEq(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.temporal_eq(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TemporalGe wraps MEOS C function temporal_ge. -func TemporalGe(temp1 *Temporal, temp2 *Temporal) bool { +func TemporalGe(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.temporal_ge(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TemporalGt wraps MEOS C function temporal_gt. -func TemporalGt(temp1 *Temporal, temp2 *Temporal) bool { +func TemporalGt(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.temporal_gt(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TemporalLe wraps MEOS C function temporal_le. -func TemporalLe(temp1 *Temporal, temp2 *Temporal) bool { +func TemporalLe(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.temporal_le(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TemporalLt wraps MEOS C function temporal_lt. -func TemporalLt(temp1 *Temporal, temp2 *Temporal) bool { +func TemporalLt(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.temporal_lt(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TemporalNe wraps MEOS C function temporal_ne. -func TemporalNe(temp1 *Temporal, temp2 *Temporal) bool { +func TemporalNe(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.temporal_ne(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AlwaysEqBoolTbool wraps MEOS C function always_eq_bool_tbool. -func AlwaysEqBoolTbool(b bool, temp *Temporal) int { +func AlwaysEqBoolTbool(b bool, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_bool_tbool(C.bool(b), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqFloatTfloat wraps MEOS C function always_eq_float_tfloat. -func AlwaysEqFloatTfloat(d float64, temp *Temporal) int { +func AlwaysEqFloatTfloat(d float64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_float_tfloat(C.double(d), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqIntTint wraps MEOS C function always_eq_int_tint. -func AlwaysEqIntTint(i int, temp *Temporal) int { +func AlwaysEqIntTint(i int, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_int_tint(C.int(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTboolBool wraps MEOS C function always_eq_tbool_bool. -func AlwaysEqTboolBool(temp *Temporal, b bool) int { +func AlwaysEqTboolBool(temp *Temporal, b bool) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_tbool_bool(temp._inner, C.bool(b)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTemporalTemporal wraps MEOS C function always_eq_temporal_temporal. -func AlwaysEqTemporalTemporal(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysEqTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_temporal_temporal(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTextTtext wraps MEOS C function always_eq_text_ttext. -func AlwaysEqTextTtext(txt string, temp *Temporal) int { +func AlwaysEqTextTtext(txt string, temp *Temporal) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.always_eq_text_ttext(_c_txt, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTfloatFloat wraps MEOS C function always_eq_tfloat_float. -func AlwaysEqTfloatFloat(temp *Temporal, d float64) int { +func AlwaysEqTfloatFloat(temp *Temporal, d float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_tfloat_float(temp._inner, C.double(d)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTintInt wraps MEOS C function always_eq_tint_int. -func AlwaysEqTintInt(temp *Temporal, i int) int { +func AlwaysEqTintInt(temp *Temporal, i int) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_tint_int(temp._inner, C.int(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqBigintTbigint wraps MEOS C function always_eq_bigint_tbigint. -func AlwaysEqBigintTbigint(i int64, temp *Temporal) int { +func AlwaysEqBigintTbigint(i int64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_bigint_tbigint(C.int64_t(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTbigintBigint wraps MEOS C function always_eq_tbigint_bigint. -func AlwaysEqTbigintBigint(temp *Temporal, i int64) int { +func AlwaysEqTbigintBigint(temp *Temporal, i int64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_tbigint_bigint(temp._inner, C.int64_t(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTtextText wraps MEOS C function always_eq_ttext_text. -func AlwaysEqTtextText(temp *Temporal, txt string) int { +func AlwaysEqTtextText(temp *Temporal, txt string) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.always_eq_ttext_text(temp._inner, _c_txt) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysGeFloatTfloat wraps MEOS C function always_ge_float_tfloat. -func AlwaysGeFloatTfloat(d float64, temp *Temporal) int { +func AlwaysGeFloatTfloat(d float64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ge_float_tfloat(C.double(d), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysGeIntTint wraps MEOS C function always_ge_int_tint. -func AlwaysGeIntTint(i int, temp *Temporal) int { +func AlwaysGeIntTint(i int, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ge_int_tint(C.int(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysGeTemporalTemporal wraps MEOS C function always_ge_temporal_temporal. -func AlwaysGeTemporalTemporal(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysGeTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ge_temporal_temporal(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysGeTextTtext wraps MEOS C function always_ge_text_ttext. -func AlwaysGeTextTtext(txt string, temp *Temporal) int { +func AlwaysGeTextTtext(txt string, temp *Temporal) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.always_ge_text_ttext(_c_txt, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysGeTfloatFloat wraps MEOS C function always_ge_tfloat_float. -func AlwaysGeTfloatFloat(temp *Temporal, d float64) int { +func AlwaysGeTfloatFloat(temp *Temporal, d float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ge_tfloat_float(temp._inner, C.double(d)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysGeTintInt wraps MEOS C function always_ge_tint_int. -func AlwaysGeTintInt(temp *Temporal, i int) int { +func AlwaysGeTintInt(temp *Temporal, i int) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ge_tint_int(temp._inner, C.int(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysGeBigintTbigint wraps MEOS C function always_ge_bigint_tbigint. -func AlwaysGeBigintTbigint(i int64, temp *Temporal) int { +func AlwaysGeBigintTbigint(i int64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ge_bigint_tbigint(C.int64_t(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysGeTbigintBigint wraps MEOS C function always_ge_tbigint_bigint. -func AlwaysGeTbigintBigint(temp *Temporal, i int64) int { +func AlwaysGeTbigintBigint(temp *Temporal, i int64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ge_tbigint_bigint(temp._inner, C.int64_t(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysGeTtextText wraps MEOS C function always_ge_ttext_text. -func AlwaysGeTtextText(temp *Temporal, txt string) int { +func AlwaysGeTtextText(temp *Temporal, txt string) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.always_ge_ttext_text(temp._inner, _c_txt) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysGtFloatTfloat wraps MEOS C function always_gt_float_tfloat. -func AlwaysGtFloatTfloat(d float64, temp *Temporal) int { +func AlwaysGtFloatTfloat(d float64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_gt_float_tfloat(C.double(d), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysGtIntTint wraps MEOS C function always_gt_int_tint. -func AlwaysGtIntTint(i int, temp *Temporal) int { +func AlwaysGtIntTint(i int, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_gt_int_tint(C.int(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysGtTemporalTemporal wraps MEOS C function always_gt_temporal_temporal. -func AlwaysGtTemporalTemporal(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysGtTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_gt_temporal_temporal(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysGtTextTtext wraps MEOS C function always_gt_text_ttext. -func AlwaysGtTextTtext(txt string, temp *Temporal) int { +func AlwaysGtTextTtext(txt string, temp *Temporal) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.always_gt_text_ttext(_c_txt, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysGtTfloatFloat wraps MEOS C function always_gt_tfloat_float. -func AlwaysGtTfloatFloat(temp *Temporal, d float64) int { +func AlwaysGtTfloatFloat(temp *Temporal, d float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_gt_tfloat_float(temp._inner, C.double(d)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysGtTintInt wraps MEOS C function always_gt_tint_int. -func AlwaysGtTintInt(temp *Temporal, i int) int { +func AlwaysGtTintInt(temp *Temporal, i int) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_gt_tint_int(temp._inner, C.int(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysGtBigintTbigint wraps MEOS C function always_gt_bigint_tbigint. -func AlwaysGtBigintTbigint(i int64, temp *Temporal) int { +func AlwaysGtBigintTbigint(i int64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_gt_bigint_tbigint(C.int64_t(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysGtTbigintBigint wraps MEOS C function always_gt_tbigint_bigint. -func AlwaysGtTbigintBigint(temp *Temporal, i int64) int { +func AlwaysGtTbigintBigint(temp *Temporal, i int64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_gt_tbigint_bigint(temp._inner, C.int64_t(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysGtTtextText wraps MEOS C function always_gt_ttext_text. -func AlwaysGtTtextText(temp *Temporal, txt string) int { +func AlwaysGtTtextText(temp *Temporal, txt string) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.always_gt_ttext_text(temp._inner, _c_txt) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysLeFloatTfloat wraps MEOS C function always_le_float_tfloat. -func AlwaysLeFloatTfloat(d float64, temp *Temporal) int { +func AlwaysLeFloatTfloat(d float64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_le_float_tfloat(C.double(d), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysLeIntTint wraps MEOS C function always_le_int_tint. -func AlwaysLeIntTint(i int, temp *Temporal) int { +func AlwaysLeIntTint(i int, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_le_int_tint(C.int(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysLeTemporalTemporal wraps MEOS C function always_le_temporal_temporal. -func AlwaysLeTemporalTemporal(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysLeTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_le_temporal_temporal(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysLeTextTtext wraps MEOS C function always_le_text_ttext. -func AlwaysLeTextTtext(txt string, temp *Temporal) int { +func AlwaysLeTextTtext(txt string, temp *Temporal) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.always_le_text_ttext(_c_txt, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysLeTfloatFloat wraps MEOS C function always_le_tfloat_float. -func AlwaysLeTfloatFloat(temp *Temporal, d float64) int { +func AlwaysLeTfloatFloat(temp *Temporal, d float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_le_tfloat_float(temp._inner, C.double(d)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysLeTintInt wraps MEOS C function always_le_tint_int. -func AlwaysLeTintInt(temp *Temporal, i int) int { +func AlwaysLeTintInt(temp *Temporal, i int) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_le_tint_int(temp._inner, C.int(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysLeBigintTbigint wraps MEOS C function always_le_bigint_tbigint. -func AlwaysLeBigintTbigint(i int64, temp *Temporal) int { +func AlwaysLeBigintTbigint(i int64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_le_bigint_tbigint(C.int64_t(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysLeTbigintBigint wraps MEOS C function always_le_tbigint_bigint. -func AlwaysLeTbigintBigint(temp *Temporal, i int64) int { +func AlwaysLeTbigintBigint(temp *Temporal, i int64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_le_tbigint_bigint(temp._inner, C.int64_t(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysLeTtextText wraps MEOS C function always_le_ttext_text. -func AlwaysLeTtextText(temp *Temporal, txt string) int { +func AlwaysLeTtextText(temp *Temporal, txt string) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.always_le_ttext_text(temp._inner, _c_txt) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysLtFloatTfloat wraps MEOS C function always_lt_float_tfloat. -func AlwaysLtFloatTfloat(d float64, temp *Temporal) int { +func AlwaysLtFloatTfloat(d float64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_lt_float_tfloat(C.double(d), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysLtIntTint wraps MEOS C function always_lt_int_tint. -func AlwaysLtIntTint(i int, temp *Temporal) int { +func AlwaysLtIntTint(i int, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_lt_int_tint(C.int(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysLtTemporalTemporal wraps MEOS C function always_lt_temporal_temporal. -func AlwaysLtTemporalTemporal(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysLtTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_lt_temporal_temporal(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysLtTextTtext wraps MEOS C function always_lt_text_ttext. -func AlwaysLtTextTtext(txt string, temp *Temporal) int { +func AlwaysLtTextTtext(txt string, temp *Temporal) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.always_lt_text_ttext(_c_txt, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysLtTfloatFloat wraps MEOS C function always_lt_tfloat_float. -func AlwaysLtTfloatFloat(temp *Temporal, d float64) int { +func AlwaysLtTfloatFloat(temp *Temporal, d float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_lt_tfloat_float(temp._inner, C.double(d)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysLtTintInt wraps MEOS C function always_lt_tint_int. -func AlwaysLtTintInt(temp *Temporal, i int) int { +func AlwaysLtTintInt(temp *Temporal, i int) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_lt_tint_int(temp._inner, C.int(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysLtBigintTbigint wraps MEOS C function always_lt_bigint_tbigint. -func AlwaysLtBigintTbigint(i int64, temp *Temporal) int { +func AlwaysLtBigintTbigint(i int64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_lt_bigint_tbigint(C.int64_t(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysLtTbigintBigint wraps MEOS C function always_lt_tbigint_bigint. -func AlwaysLtTbigintBigint(temp *Temporal, i int64) int { +func AlwaysLtTbigintBigint(temp *Temporal, i int64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_lt_tbigint_bigint(temp._inner, C.int64_t(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysLtTtextText wraps MEOS C function always_lt_ttext_text. -func AlwaysLtTtextText(temp *Temporal, txt string) int { +func AlwaysLtTtextText(temp *Temporal, txt string) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.always_lt_ttext_text(temp._inner, _c_txt) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeBoolTbool wraps MEOS C function always_ne_bool_tbool. -func AlwaysNeBoolTbool(b bool, temp *Temporal) int { +func AlwaysNeBoolTbool(b bool, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_bool_tbool(C.bool(b), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeFloatTfloat wraps MEOS C function always_ne_float_tfloat. -func AlwaysNeFloatTfloat(d float64, temp *Temporal) int { +func AlwaysNeFloatTfloat(d float64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_float_tfloat(C.double(d), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeIntTint wraps MEOS C function always_ne_int_tint. -func AlwaysNeIntTint(i int, temp *Temporal) int { +func AlwaysNeIntTint(i int, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_int_tint(C.int(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTboolBool wraps MEOS C function always_ne_tbool_bool. -func AlwaysNeTboolBool(temp *Temporal, b bool) int { +func AlwaysNeTboolBool(temp *Temporal, b bool) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_tbool_bool(temp._inner, C.bool(b)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTemporalTemporal wraps MEOS C function always_ne_temporal_temporal. -func AlwaysNeTemporalTemporal(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysNeTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_temporal_temporal(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTextTtext wraps MEOS C function always_ne_text_ttext. -func AlwaysNeTextTtext(txt string, temp *Temporal) int { +func AlwaysNeTextTtext(txt string, temp *Temporal) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.always_ne_text_ttext(_c_txt, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTfloatFloat wraps MEOS C function always_ne_tfloat_float. -func AlwaysNeTfloatFloat(temp *Temporal, d float64) int { +func AlwaysNeTfloatFloat(temp *Temporal, d float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_tfloat_float(temp._inner, C.double(d)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTintInt wraps MEOS C function always_ne_tint_int. -func AlwaysNeTintInt(temp *Temporal, i int) int { +func AlwaysNeTintInt(temp *Temporal, i int) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_tint_int(temp._inner, C.int(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeBigintTbigint wraps MEOS C function always_ne_bigint_tbigint. -func AlwaysNeBigintTbigint(i int64, temp *Temporal) int { +func AlwaysNeBigintTbigint(i int64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_bigint_tbigint(C.int64_t(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTbigintBigint wraps MEOS C function always_ne_tbigint_bigint. -func AlwaysNeTbigintBigint(temp *Temporal, i int64) int { +func AlwaysNeTbigintBigint(temp *Temporal, i int64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_tbigint_bigint(temp._inner, C.int64_t(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTtextText wraps MEOS C function always_ne_ttext_text. -func AlwaysNeTtextText(temp *Temporal, txt string) int { +func AlwaysNeTtextText(temp *Temporal, txt string) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.always_ne_ttext_text(temp._inner, _c_txt) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqBoolTbool wraps MEOS C function ever_eq_bool_tbool. -func EverEqBoolTbool(b bool, temp *Temporal) int { +func EverEqBoolTbool(b bool, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_bool_tbool(C.bool(b), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqFloatTfloat wraps MEOS C function ever_eq_float_tfloat. -func EverEqFloatTfloat(d float64, temp *Temporal) int { +func EverEqFloatTfloat(d float64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_float_tfloat(C.double(d), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqIntTint wraps MEOS C function ever_eq_int_tint. -func EverEqIntTint(i int, temp *Temporal) int { +func EverEqIntTint(i int, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_int_tint(C.int(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTboolBool wraps MEOS C function ever_eq_tbool_bool. -func EverEqTboolBool(temp *Temporal, b bool) int { +func EverEqTboolBool(temp *Temporal, b bool) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_tbool_bool(temp._inner, C.bool(b)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTemporalTemporal wraps MEOS C function ever_eq_temporal_temporal. -func EverEqTemporalTemporal(temp1 *Temporal, temp2 *Temporal) int { +func EverEqTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_temporal_temporal(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTextTtext wraps MEOS C function ever_eq_text_ttext. -func EverEqTextTtext(txt string, temp *Temporal) int { +func EverEqTextTtext(txt string, temp *Temporal) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.ever_eq_text_ttext(_c_txt, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTfloatFloat wraps MEOS C function ever_eq_tfloat_float. -func EverEqTfloatFloat(temp *Temporal, d float64) int { +func EverEqTfloatFloat(temp *Temporal, d float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_tfloat_float(temp._inner, C.double(d)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTintInt wraps MEOS C function ever_eq_tint_int. -func EverEqTintInt(temp *Temporal, i int) int { +func EverEqTintInt(temp *Temporal, i int) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_tint_int(temp._inner, C.int(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqBigintTbigint wraps MEOS C function ever_eq_bigint_tbigint. -func EverEqBigintTbigint(i int64, temp *Temporal) int { +func EverEqBigintTbigint(i int64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_bigint_tbigint(C.int64_t(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTbigintBigint wraps MEOS C function ever_eq_tbigint_bigint. -func EverEqTbigintBigint(temp *Temporal, i int64) int { +func EverEqTbigintBigint(temp *Temporal, i int64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_tbigint_bigint(temp._inner, C.int64_t(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTtextText wraps MEOS C function ever_eq_ttext_text. -func EverEqTtextText(temp *Temporal, txt string) int { +func EverEqTtextText(temp *Temporal, txt string) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.ever_eq_ttext_text(temp._inner, _c_txt) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverGeFloatTfloat wraps MEOS C function ever_ge_float_tfloat. -func EverGeFloatTfloat(d float64, temp *Temporal) int { +func EverGeFloatTfloat(d float64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ge_float_tfloat(C.double(d), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverGeIntTint wraps MEOS C function ever_ge_int_tint. -func EverGeIntTint(i int, temp *Temporal) int { +func EverGeIntTint(i int, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ge_int_tint(C.int(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverGeTemporalTemporal wraps MEOS C function ever_ge_temporal_temporal. -func EverGeTemporalTemporal(temp1 *Temporal, temp2 *Temporal) int { +func EverGeTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ge_temporal_temporal(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverGeTextTtext wraps MEOS C function ever_ge_text_ttext. -func EverGeTextTtext(txt string, temp *Temporal) int { +func EverGeTextTtext(txt string, temp *Temporal) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.ever_ge_text_ttext(_c_txt, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverGeTfloatFloat wraps MEOS C function ever_ge_tfloat_float. -func EverGeTfloatFloat(temp *Temporal, d float64) int { +func EverGeTfloatFloat(temp *Temporal, d float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ge_tfloat_float(temp._inner, C.double(d)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverGeTintInt wraps MEOS C function ever_ge_tint_int. -func EverGeTintInt(temp *Temporal, i int) int { +func EverGeTintInt(temp *Temporal, i int) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ge_tint_int(temp._inner, C.int(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverGeBigintTbigint wraps MEOS C function ever_ge_bigint_tbigint. -func EverGeBigintTbigint(i int64, temp *Temporal) int { +func EverGeBigintTbigint(i int64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ge_bigint_tbigint(C.int64_t(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverGeTbigintBigint wraps MEOS C function ever_ge_tbigint_bigint. -func EverGeTbigintBigint(temp *Temporal, i int64) int { +func EverGeTbigintBigint(temp *Temporal, i int64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ge_tbigint_bigint(temp._inner, C.int64_t(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverGeTtextText wraps MEOS C function ever_ge_ttext_text. -func EverGeTtextText(temp *Temporal, txt string) int { +func EverGeTtextText(temp *Temporal, txt string) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.ever_ge_ttext_text(temp._inner, _c_txt) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverGtFloatTfloat wraps MEOS C function ever_gt_float_tfloat. -func EverGtFloatTfloat(d float64, temp *Temporal) int { +func EverGtFloatTfloat(d float64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_gt_float_tfloat(C.double(d), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverGtIntTint wraps MEOS C function ever_gt_int_tint. -func EverGtIntTint(i int, temp *Temporal) int { +func EverGtIntTint(i int, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_gt_int_tint(C.int(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverGtTemporalTemporal wraps MEOS C function ever_gt_temporal_temporal. -func EverGtTemporalTemporal(temp1 *Temporal, temp2 *Temporal) int { +func EverGtTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_gt_temporal_temporal(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverGtTextTtext wraps MEOS C function ever_gt_text_ttext. -func EverGtTextTtext(txt string, temp *Temporal) int { +func EverGtTextTtext(txt string, temp *Temporal) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.ever_gt_text_ttext(_c_txt, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverGtTfloatFloat wraps MEOS C function ever_gt_tfloat_float. -func EverGtTfloatFloat(temp *Temporal, d float64) int { +func EverGtTfloatFloat(temp *Temporal, d float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_gt_tfloat_float(temp._inner, C.double(d)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverGtTintInt wraps MEOS C function ever_gt_tint_int. -func EverGtTintInt(temp *Temporal, i int) int { +func EverGtTintInt(temp *Temporal, i int) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_gt_tint_int(temp._inner, C.int(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverGtBigintTbigint wraps MEOS C function ever_gt_bigint_tbigint. -func EverGtBigintTbigint(i int64, temp *Temporal) int { +func EverGtBigintTbigint(i int64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_gt_bigint_tbigint(C.int64_t(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverGtTbigintBigint wraps MEOS C function ever_gt_tbigint_bigint. -func EverGtTbigintBigint(temp *Temporal, i int64) int { +func EverGtTbigintBigint(temp *Temporal, i int64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_gt_tbigint_bigint(temp._inner, C.int64_t(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverGtTtextText wraps MEOS C function ever_gt_ttext_text. -func EverGtTtextText(temp *Temporal, txt string) int { +func EverGtTtextText(temp *Temporal, txt string) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.ever_gt_ttext_text(temp._inner, _c_txt) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverLeFloatTfloat wraps MEOS C function ever_le_float_tfloat. -func EverLeFloatTfloat(d float64, temp *Temporal) int { +func EverLeFloatTfloat(d float64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_le_float_tfloat(C.double(d), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverLeIntTint wraps MEOS C function ever_le_int_tint. -func EverLeIntTint(i int, temp *Temporal) int { +func EverLeIntTint(i int, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_le_int_tint(C.int(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverLeTemporalTemporal wraps MEOS C function ever_le_temporal_temporal. -func EverLeTemporalTemporal(temp1 *Temporal, temp2 *Temporal) int { +func EverLeTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_le_temporal_temporal(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverLeTextTtext wraps MEOS C function ever_le_text_ttext. -func EverLeTextTtext(txt string, temp *Temporal) int { +func EverLeTextTtext(txt string, temp *Temporal) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.ever_le_text_ttext(_c_txt, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverLeTfloatFloat wraps MEOS C function ever_le_tfloat_float. -func EverLeTfloatFloat(temp *Temporal, d float64) int { +func EverLeTfloatFloat(temp *Temporal, d float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_le_tfloat_float(temp._inner, C.double(d)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverLeTintInt wraps MEOS C function ever_le_tint_int. -func EverLeTintInt(temp *Temporal, i int) int { +func EverLeTintInt(temp *Temporal, i int) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_le_tint_int(temp._inner, C.int(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverLeBigintTbigint wraps MEOS C function ever_le_bigint_tbigint. -func EverLeBigintTbigint(i int64, temp *Temporal) int { +func EverLeBigintTbigint(i int64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_le_bigint_tbigint(C.int64_t(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverLeTbigintBigint wraps MEOS C function ever_le_tbigint_bigint. -func EverLeTbigintBigint(temp *Temporal, i int64) int { +func EverLeTbigintBigint(temp *Temporal, i int64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_le_tbigint_bigint(temp._inner, C.int64_t(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverLeTtextText wraps MEOS C function ever_le_ttext_text. -func EverLeTtextText(temp *Temporal, txt string) int { +func EverLeTtextText(temp *Temporal, txt string) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.ever_le_ttext_text(temp._inner, _c_txt) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverLtFloatTfloat wraps MEOS C function ever_lt_float_tfloat. -func EverLtFloatTfloat(d float64, temp *Temporal) int { +func EverLtFloatTfloat(d float64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_lt_float_tfloat(C.double(d), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverLtIntTint wraps MEOS C function ever_lt_int_tint. -func EverLtIntTint(i int, temp *Temporal) int { +func EverLtIntTint(i int, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_lt_int_tint(C.int(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverLtTemporalTemporal wraps MEOS C function ever_lt_temporal_temporal. -func EverLtTemporalTemporal(temp1 *Temporal, temp2 *Temporal) int { +func EverLtTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_lt_temporal_temporal(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverLtTextTtext wraps MEOS C function ever_lt_text_ttext. -func EverLtTextTtext(txt string, temp *Temporal) int { +func EverLtTextTtext(txt string, temp *Temporal) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.ever_lt_text_ttext(_c_txt, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverLtTfloatFloat wraps MEOS C function ever_lt_tfloat_float. -func EverLtTfloatFloat(temp *Temporal, d float64) int { +func EverLtTfloatFloat(temp *Temporal, d float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_lt_tfloat_float(temp._inner, C.double(d)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverLtTintInt wraps MEOS C function ever_lt_tint_int. -func EverLtTintInt(temp *Temporal, i int) int { +func EverLtTintInt(temp *Temporal, i int) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_lt_tint_int(temp._inner, C.int(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverLtBigintTbigint wraps MEOS C function ever_lt_bigint_tbigint. -func EverLtBigintTbigint(i int64, temp *Temporal) int { +func EverLtBigintTbigint(i int64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_lt_bigint_tbigint(C.int64_t(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverLtTbigintBigint wraps MEOS C function ever_lt_tbigint_bigint. -func EverLtTbigintBigint(temp *Temporal, i int64) int { +func EverLtTbigintBigint(temp *Temporal, i int64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_lt_tbigint_bigint(temp._inner, C.int64_t(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverLtTtextText wraps MEOS C function ever_lt_ttext_text. -func EverLtTtextText(temp *Temporal, txt string) int { +func EverLtTtextText(temp *Temporal, txt string) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.ever_lt_ttext_text(temp._inner, _c_txt) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeBoolTbool wraps MEOS C function ever_ne_bool_tbool. -func EverNeBoolTbool(b bool, temp *Temporal) int { +func EverNeBoolTbool(b bool, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_bool_tbool(C.bool(b), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeFloatTfloat wraps MEOS C function ever_ne_float_tfloat. -func EverNeFloatTfloat(d float64, temp *Temporal) int { +func EverNeFloatTfloat(d float64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_float_tfloat(C.double(d), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeIntTint wraps MEOS C function ever_ne_int_tint. -func EverNeIntTint(i int, temp *Temporal) int { +func EverNeIntTint(i int, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_int_tint(C.int(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTboolBool wraps MEOS C function ever_ne_tbool_bool. -func EverNeTboolBool(temp *Temporal, b bool) int { +func EverNeTboolBool(temp *Temporal, b bool) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_tbool_bool(temp._inner, C.bool(b)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTemporalTemporal wraps MEOS C function ever_ne_temporal_temporal. -func EverNeTemporalTemporal(temp1 *Temporal, temp2 *Temporal) int { +func EverNeTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_temporal_temporal(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTextTtext wraps MEOS C function ever_ne_text_ttext. -func EverNeTextTtext(txt string, temp *Temporal) int { +func EverNeTextTtext(txt string, temp *Temporal) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.ever_ne_text_ttext(_c_txt, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTfloatFloat wraps MEOS C function ever_ne_tfloat_float. -func EverNeTfloatFloat(temp *Temporal, d float64) int { +func EverNeTfloatFloat(temp *Temporal, d float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_tfloat_float(temp._inner, C.double(d)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTintInt wraps MEOS C function ever_ne_tint_int. -func EverNeTintInt(temp *Temporal, i int) int { +func EverNeTintInt(temp *Temporal, i int) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_tint_int(temp._inner, C.int(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeBigintTbigint wraps MEOS C function ever_ne_bigint_tbigint. -func EverNeBigintTbigint(i int64, temp *Temporal) int { +func EverNeBigintTbigint(i int64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_bigint_tbigint(C.int64_t(i), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTbigintBigint wraps MEOS C function ever_ne_tbigint_bigint. -func EverNeTbigintBigint(temp *Temporal, i int64) int { +func EverNeTbigintBigint(temp *Temporal, i int64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_tbigint_bigint(temp._inner, C.int64_t(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTtextText wraps MEOS C function ever_ne_ttext_text. -func EverNeTtextText(temp *Temporal, txt string) int { +func EverNeTtextText(temp *Temporal, txt string) (_r0 int, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.ever_ne_ttext_text(temp._inner, _c_txt) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TeqBoolTbool wraps MEOS C function teq_bool_tbool. -func TeqBoolTbool(b bool, temp *Temporal) *Temporal { +func TeqBoolTbool(b bool, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_bool_tbool(C.bool(b), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TeqFloatTfloat wraps MEOS C function teq_float_tfloat. -func TeqFloatTfloat(d float64, temp *Temporal) *Temporal { +func TeqFloatTfloat(d float64, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_float_tfloat(C.double(d), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TeqIntTint wraps MEOS C function teq_int_tint. -func TeqIntTint(i int, temp *Temporal) *Temporal { +func TeqIntTint(i int, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_int_tint(C.int(i), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TeqTboolBool wraps MEOS C function teq_tbool_bool. -func TeqTboolBool(temp *Temporal, b bool) *Temporal { +func TeqTboolBool(temp *Temporal, b bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_tbool_bool(temp._inner, C.bool(b)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TeqTemporalTemporal wraps MEOS C function teq_temporal_temporal. -func TeqTemporalTemporal(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TeqTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_temporal_temporal(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TeqTextTtext wraps MEOS C function teq_text_ttext. -func TeqTextTtext(txt string, temp *Temporal) *Temporal { +func TeqTextTtext(txt string, temp *Temporal) (_r0 *Temporal, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.teq_text_ttext(_c_txt, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TeqTfloatFloat wraps MEOS C function teq_tfloat_float. -func TeqTfloatFloat(temp *Temporal, d float64) *Temporal { +func TeqTfloatFloat(temp *Temporal, d float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_tfloat_float(temp._inner, C.double(d)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TeqTintInt wraps MEOS C function teq_tint_int. -func TeqTintInt(temp *Temporal, i int) *Temporal { +func TeqTintInt(temp *Temporal, i int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_tint_int(temp._inner, C.int(i)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TeqTtextText wraps MEOS C function teq_ttext_text. -func TeqTtextText(temp *Temporal, txt string) *Temporal { +func TeqTtextText(temp *Temporal, txt string) (_r0 *Temporal, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.teq_ttext_text(temp._inner, _c_txt) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeFloatTfloat wraps MEOS C function tge_float_tfloat. -func TgeFloatTfloat(d float64, temp *Temporal) *Temporal { +func TgeFloatTfloat(d float64, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tge_float_tfloat(C.double(d), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeIntTint wraps MEOS C function tge_int_tint. -func TgeIntTint(i int, temp *Temporal) *Temporal { +func TgeIntTint(i int, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tge_int_tint(C.int(i), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeTemporalTemporal wraps MEOS C function tge_temporal_temporal. -func TgeTemporalTemporal(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TgeTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tge_temporal_temporal(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeTextTtext wraps MEOS C function tge_text_ttext. -func TgeTextTtext(txt string, temp *Temporal) *Temporal { +func TgeTextTtext(txt string, temp *Temporal) (_r0 *Temporal, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.tge_text_ttext(_c_txt, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeTfloatFloat wraps MEOS C function tge_tfloat_float. -func TgeTfloatFloat(temp *Temporal, d float64) *Temporal { +func TgeTfloatFloat(temp *Temporal, d float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tge_tfloat_float(temp._inner, C.double(d)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeTintInt wraps MEOS C function tge_tint_int. -func TgeTintInt(temp *Temporal, i int) *Temporal { +func TgeTintInt(temp *Temporal, i int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tge_tint_int(temp._inner, C.int(i)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeTtextText wraps MEOS C function tge_ttext_text. -func TgeTtextText(temp *Temporal, txt string) *Temporal { +func TgeTtextText(temp *Temporal, txt string) (_r0 *Temporal, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.tge_ttext_text(temp._inner, _c_txt) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgtFloatTfloat wraps MEOS C function tgt_float_tfloat. -func TgtFloatTfloat(d float64, temp *Temporal) *Temporal { +func TgtFloatTfloat(d float64, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgt_float_tfloat(C.double(d), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgtIntTint wraps MEOS C function tgt_int_tint. -func TgtIntTint(i int, temp *Temporal) *Temporal { +func TgtIntTint(i int, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgt_int_tint(C.int(i), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgtTemporalTemporal wraps MEOS C function tgt_temporal_temporal. -func TgtTemporalTemporal(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TgtTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgt_temporal_temporal(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgtTextTtext wraps MEOS C function tgt_text_ttext. -func TgtTextTtext(txt string, temp *Temporal) *Temporal { +func TgtTextTtext(txt string, temp *Temporal) (_r0 *Temporal, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.tgt_text_ttext(_c_txt, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgtTfloatFloat wraps MEOS C function tgt_tfloat_float. -func TgtTfloatFloat(temp *Temporal, d float64) *Temporal { +func TgtTfloatFloat(temp *Temporal, d float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgt_tfloat_float(temp._inner, C.double(d)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgtTintInt wraps MEOS C function tgt_tint_int. -func TgtTintInt(temp *Temporal, i int) *Temporal { +func TgtTintInt(temp *Temporal, i int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgt_tint_int(temp._inner, C.int(i)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgtTtextText wraps MEOS C function tgt_ttext_text. -func TgtTtextText(temp *Temporal, txt string) *Temporal { +func TgtTtextText(temp *Temporal, txt string) (_r0 *Temporal, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.tgt_ttext_text(temp._inner, _c_txt) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TleFloatTfloat wraps MEOS C function tle_float_tfloat. -func TleFloatTfloat(d float64, temp *Temporal) *Temporal { +func TleFloatTfloat(d float64, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tle_float_tfloat(C.double(d), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TleIntTint wraps MEOS C function tle_int_tint. -func TleIntTint(i int, temp *Temporal) *Temporal { +func TleIntTint(i int, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tle_int_tint(C.int(i), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TleTemporalTemporal wraps MEOS C function tle_temporal_temporal. -func TleTemporalTemporal(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TleTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tle_temporal_temporal(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TleTextTtext wraps MEOS C function tle_text_ttext. -func TleTextTtext(txt string, temp *Temporal) *Temporal { +func TleTextTtext(txt string, temp *Temporal) (_r0 *Temporal, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.tle_text_ttext(_c_txt, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TleTfloatFloat wraps MEOS C function tle_tfloat_float. -func TleTfloatFloat(temp *Temporal, d float64) *Temporal { +func TleTfloatFloat(temp *Temporal, d float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tle_tfloat_float(temp._inner, C.double(d)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TleTintInt wraps MEOS C function tle_tint_int. -func TleTintInt(temp *Temporal, i int) *Temporal { +func TleTintInt(temp *Temporal, i int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tle_tint_int(temp._inner, C.int(i)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TleTtextText wraps MEOS C function tle_ttext_text. -func TleTtextText(temp *Temporal, txt string) *Temporal { +func TleTtextText(temp *Temporal, txt string) (_r0 *Temporal, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.tle_ttext_text(temp._inner, _c_txt) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TltFloatTfloat wraps MEOS C function tlt_float_tfloat. -func TltFloatTfloat(d float64, temp *Temporal) *Temporal { +func TltFloatTfloat(d float64, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tlt_float_tfloat(C.double(d), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TltIntTint wraps MEOS C function tlt_int_tint. -func TltIntTint(i int, temp *Temporal) *Temporal { +func TltIntTint(i int, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tlt_int_tint(C.int(i), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TltTemporalTemporal wraps MEOS C function tlt_temporal_temporal. -func TltTemporalTemporal(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TltTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tlt_temporal_temporal(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TltTextTtext wraps MEOS C function tlt_text_ttext. -func TltTextTtext(txt string, temp *Temporal) *Temporal { +func TltTextTtext(txt string, temp *Temporal) (_r0 *Temporal, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.tlt_text_ttext(_c_txt, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TltTfloatFloat wraps MEOS C function tlt_tfloat_float. -func TltTfloatFloat(temp *Temporal, d float64) *Temporal { +func TltTfloatFloat(temp *Temporal, d float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tlt_tfloat_float(temp._inner, C.double(d)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TltTintInt wraps MEOS C function tlt_tint_int. -func TltTintInt(temp *Temporal, i int) *Temporal { +func TltTintInt(temp *Temporal, i int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tlt_tint_int(temp._inner, C.int(i)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TltTtextText wraps MEOS C function tlt_ttext_text. -func TltTtextText(temp *Temporal, txt string) *Temporal { +func TltTtextText(temp *Temporal, txt string) (_r0 *Temporal, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.tlt_ttext_text(temp._inner, _c_txt) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneBoolTbool wraps MEOS C function tne_bool_tbool. -func TneBoolTbool(b bool, temp *Temporal) *Temporal { +func TneBoolTbool(b bool, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_bool_tbool(C.bool(b), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneFloatTfloat wraps MEOS C function tne_float_tfloat. -func TneFloatTfloat(d float64, temp *Temporal) *Temporal { +func TneFloatTfloat(d float64, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_float_tfloat(C.double(d), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneIntTint wraps MEOS C function tne_int_tint. -func TneIntTint(i int, temp *Temporal) *Temporal { +func TneIntTint(i int, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_int_tint(C.int(i), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneTboolBool wraps MEOS C function tne_tbool_bool. -func TneTboolBool(temp *Temporal, b bool) *Temporal { +func TneTboolBool(temp *Temporal, b bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_tbool_bool(temp._inner, C.bool(b)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneTemporalTemporal wraps MEOS C function tne_temporal_temporal. -func TneTemporalTemporal(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TneTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_temporal_temporal(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneTextTtext wraps MEOS C function tne_text_ttext. -func TneTextTtext(txt string, temp *Temporal) *Temporal { +func TneTextTtext(txt string, temp *Temporal) (_r0 *Temporal, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.tne_text_ttext(_c_txt, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneTfloatFloat wraps MEOS C function tne_tfloat_float. -func TneTfloatFloat(temp *Temporal, d float64) *Temporal { +func TneTfloatFloat(temp *Temporal, d float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_tfloat_float(temp._inner, C.double(d)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneTintInt wraps MEOS C function tne_tint_int. -func TneTintInt(temp *Temporal, i int) *Temporal { +func TneTintInt(temp *Temporal, i int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_tint_int(temp._inner, C.int(i)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneTtextText wraps MEOS C function tne_ttext_text. -func TneTtextText(temp *Temporal, txt string) *Temporal { +func TneTtextText(temp *Temporal, txt string) (_r0 *Temporal, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.tne_ttext_text(temp._inner, _c_txt) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalSpans wraps MEOS C function temporal_spans. -func TemporalSpans(temp *Temporal, count unsafe.Pointer) *Span { +func TemporalSpans(temp *Temporal, count unsafe.Pointer) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.temporal_spans(temp._inner, (*C.int)(unsafe.Pointer(count))) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TemporalSplitEachNSpans wraps MEOS C function temporal_split_each_n_spans. -func TemporalSplitEachNSpans(temp *Temporal, elem_count int, count unsafe.Pointer) *Span { +func TemporalSplitEachNSpans(temp *Temporal, elem_count int, count unsafe.Pointer) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.temporal_split_each_n_spans(temp._inner, C.int(elem_count), (*C.int)(unsafe.Pointer(count))) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TemporalSplitNSpans wraps MEOS C function temporal_split_n_spans. -func TemporalSplitNSpans(temp *Temporal, span_count int, count unsafe.Pointer) *Span { +func TemporalSplitNSpans(temp *Temporal, span_count int, count unsafe.Pointer) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.temporal_split_n_spans(temp._inner, C.int(span_count), (*C.int)(unsafe.Pointer(count))) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TnumberSplitEachNTboxes wraps MEOS C function tnumber_split_each_n_tboxes. -func TnumberSplitEachNTboxes(temp *Temporal, elem_count int, count unsafe.Pointer) *TBox { +func TnumberSplitEachNTboxes(temp *Temporal, elem_count int, count unsafe.Pointer) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tnumber_split_each_n_tboxes(temp._inner, C.int(elem_count), (*C.int)(unsafe.Pointer(count))) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TnumberSplitNTboxes wraps MEOS C function tnumber_split_n_tboxes. -func TnumberSplitNTboxes(temp *Temporal, box_count int, count unsafe.Pointer) *TBox { +func TnumberSplitNTboxes(temp *Temporal, box_count int, count unsafe.Pointer) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tnumber_split_n_tboxes(temp._inner, C.int(box_count), (*C.int)(unsafe.Pointer(count))) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TnumberTboxes wraps MEOS C function tnumber_tboxes. -func TnumberTboxes(temp *Temporal, count unsafe.Pointer) *TBox { +func TnumberTboxes(temp *Temporal, count unsafe.Pointer) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tnumber_tboxes(temp._inner, (*C.int)(unsafe.Pointer(count))) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // AdjacentNumspanTnumber wraps MEOS C function adjacent_numspan_tnumber. -func AdjacentNumspanTnumber(s *Span, temp *Temporal) bool { +func AdjacentNumspanTnumber(s *Span, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_numspan_tnumber(s._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentTBOXTnumber wraps MEOS C function adjacent_tbox_tnumber. -func AdjacentTBOXTnumber(box *TBox, temp *Temporal) bool { +func AdjacentTBOXTnumber(box *TBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_tbox_tnumber(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentTemporalTemporal wraps MEOS C function adjacent_temporal_temporal. -func AdjacentTemporalTemporal(temp1 *Temporal, temp2 *Temporal) bool { +func AdjacentTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_temporal_temporal(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentTemporalTstzspan wraps MEOS C function adjacent_temporal_tstzspan. -func AdjacentTemporalTstzspan(temp *Temporal, s *Span) bool { +func AdjacentTemporalTstzspan(temp *Temporal, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_temporal_tstzspan(temp._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentTnumberNumspan wraps MEOS C function adjacent_tnumber_numspan. -func AdjacentTnumberNumspan(temp *Temporal, s *Span) bool { +func AdjacentTnumberNumspan(temp *Temporal, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_tnumber_numspan(temp._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentTnumberTBOX wraps MEOS C function adjacent_tnumber_tbox. -func AdjacentTnumberTBOX(temp *Temporal, box *TBox) bool { +func AdjacentTnumberTBOX(temp *Temporal, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_tnumber_tbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentTnumberTnumber wraps MEOS C function adjacent_tnumber_tnumber. -func AdjacentTnumberTnumber(temp1 *Temporal, temp2 *Temporal) bool { +func AdjacentTnumberTnumber(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_tnumber_tnumber(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentTstzspanTemporal wraps MEOS C function adjacent_tstzspan_temporal. -func AdjacentTstzspanTemporal(s *Span, temp *Temporal) bool { +func AdjacentTstzspanTemporal(s *Span, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_tstzspan_temporal(s._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedNumspanTnumber wraps MEOS C function contained_numspan_tnumber. -func ContainedNumspanTnumber(s *Span, temp *Temporal) bool { +func ContainedNumspanTnumber(s *Span, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_numspan_tnumber(s._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedTBOXTnumber wraps MEOS C function contained_tbox_tnumber. -func ContainedTBOXTnumber(box *TBox, temp *Temporal) bool { +func ContainedTBOXTnumber(box *TBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_tbox_tnumber(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedTemporalTemporal wraps MEOS C function contained_temporal_temporal. -func ContainedTemporalTemporal(temp1 *Temporal, temp2 *Temporal) bool { +func ContainedTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_temporal_temporal(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedTemporalTstzspan wraps MEOS C function contained_temporal_tstzspan. -func ContainedTemporalTstzspan(temp *Temporal, s *Span) bool { +func ContainedTemporalTstzspan(temp *Temporal, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_temporal_tstzspan(temp._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedTnumberNumspan wraps MEOS C function contained_tnumber_numspan. -func ContainedTnumberNumspan(temp *Temporal, s *Span) bool { +func ContainedTnumberNumspan(temp *Temporal, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_tnumber_numspan(temp._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedTnumberTBOX wraps MEOS C function contained_tnumber_tbox. -func ContainedTnumberTBOX(temp *Temporal, box *TBox) bool { +func ContainedTnumberTBOX(temp *Temporal, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_tnumber_tbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedTnumberTnumber wraps MEOS C function contained_tnumber_tnumber. -func ContainedTnumberTnumber(temp1 *Temporal, temp2 *Temporal) bool { +func ContainedTnumberTnumber(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_tnumber_tnumber(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedTstzspanTemporal wraps MEOS C function contained_tstzspan_temporal. -func ContainedTstzspanTemporal(s *Span, temp *Temporal) bool { +func ContainedTstzspanTemporal(s *Span, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_tstzspan_temporal(s._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsNumspanTnumber wraps MEOS C function contains_numspan_tnumber. -func ContainsNumspanTnumber(s *Span, temp *Temporal) bool { +func ContainsNumspanTnumber(s *Span, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_numspan_tnumber(s._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsTBOXTnumber wraps MEOS C function contains_tbox_tnumber. -func ContainsTBOXTnumber(box *TBox, temp *Temporal) bool { +func ContainsTBOXTnumber(box *TBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_tbox_tnumber(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsTemporalTstzspan wraps MEOS C function contains_temporal_tstzspan. -func ContainsTemporalTstzspan(temp *Temporal, s *Span) bool { +func ContainsTemporalTstzspan(temp *Temporal, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_temporal_tstzspan(temp._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsTemporalTemporal wraps MEOS C function contains_temporal_temporal. -func ContainsTemporalTemporal(temp1 *Temporal, temp2 *Temporal) bool { +func ContainsTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_temporal_temporal(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsTnumberNumspan wraps MEOS C function contains_tnumber_numspan. -func ContainsTnumberNumspan(temp *Temporal, s *Span) bool { +func ContainsTnumberNumspan(temp *Temporal, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_tnumber_numspan(temp._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsTnumberTBOX wraps MEOS C function contains_tnumber_tbox. -func ContainsTnumberTBOX(temp *Temporal, box *TBox) bool { +func ContainsTnumberTBOX(temp *Temporal, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_tnumber_tbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsTnumberTnumber wraps MEOS C function contains_tnumber_tnumber. -func ContainsTnumberTnumber(temp1 *Temporal, temp2 *Temporal) bool { +func ContainsTnumberTnumber(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_tnumber_tnumber(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsTstzspanTemporal wraps MEOS C function contains_tstzspan_temporal. -func ContainsTstzspanTemporal(s *Span, temp *Temporal) bool { +func ContainsTstzspanTemporal(s *Span, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_tstzspan_temporal(s._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverlapsNumspanTnumber wraps MEOS C function overlaps_numspan_tnumber. -func OverlapsNumspanTnumber(s *Span, temp *Temporal) bool { +func OverlapsNumspanTnumber(s *Span, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overlaps_numspan_tnumber(s._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverlapsTBOXTnumber wraps MEOS C function overlaps_tbox_tnumber. -func OverlapsTBOXTnumber(box *TBox, temp *Temporal) bool { +func OverlapsTBOXTnumber(box *TBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overlaps_tbox_tnumber(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverlapsTemporalTemporal wraps MEOS C function overlaps_temporal_temporal. -func OverlapsTemporalTemporal(temp1 *Temporal, temp2 *Temporal) bool { +func OverlapsTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overlaps_temporal_temporal(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverlapsTemporalTstzspan wraps MEOS C function overlaps_temporal_tstzspan. -func OverlapsTemporalTstzspan(temp *Temporal, s *Span) bool { +func OverlapsTemporalTstzspan(temp *Temporal, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overlaps_temporal_tstzspan(temp._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverlapsTnumberNumspan wraps MEOS C function overlaps_tnumber_numspan. -func OverlapsTnumberNumspan(temp *Temporal, s *Span) bool { +func OverlapsTnumberNumspan(temp *Temporal, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overlaps_tnumber_numspan(temp._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverlapsTnumberTBOX wraps MEOS C function overlaps_tnumber_tbox. -func OverlapsTnumberTBOX(temp *Temporal, box *TBox) bool { +func OverlapsTnumberTBOX(temp *Temporal, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overlaps_tnumber_tbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverlapsTnumberTnumber wraps MEOS C function overlaps_tnumber_tnumber. -func OverlapsTnumberTnumber(temp1 *Temporal, temp2 *Temporal) bool { +func OverlapsTnumberTnumber(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overlaps_tnumber_tnumber(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverlapsTstzspanTemporal wraps MEOS C function overlaps_tstzspan_temporal. -func OverlapsTstzspanTemporal(s *Span, temp *Temporal) bool { +func OverlapsTstzspanTemporal(s *Span, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overlaps_tstzspan_temporal(s._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SameNumspanTnumber wraps MEOS C function same_numspan_tnumber. -func SameNumspanTnumber(s *Span, temp *Temporal) bool { +func SameNumspanTnumber(s *Span, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.same_numspan_tnumber(s._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SameTBOXTnumber wraps MEOS C function same_tbox_tnumber. -func SameTBOXTnumber(box *TBox, temp *Temporal) bool { +func SameTBOXTnumber(box *TBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.same_tbox_tnumber(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SameTemporalTemporal wraps MEOS C function same_temporal_temporal. -func SameTemporalTemporal(temp1 *Temporal, temp2 *Temporal) bool { +func SameTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.same_temporal_temporal(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SameTemporalTstzspan wraps MEOS C function same_temporal_tstzspan. -func SameTemporalTstzspan(temp *Temporal, s *Span) bool { +func SameTemporalTstzspan(temp *Temporal, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.same_temporal_tstzspan(temp._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SameTnumberNumspan wraps MEOS C function same_tnumber_numspan. -func SameTnumberNumspan(temp *Temporal, s *Span) bool { +func SameTnumberNumspan(temp *Temporal, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.same_tnumber_numspan(temp._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SameTnumberTBOX wraps MEOS C function same_tnumber_tbox. -func SameTnumberTBOX(temp *Temporal, box *TBox) bool { +func SameTnumberTBOX(temp *Temporal, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.same_tnumber_tbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SameTnumberTnumber wraps MEOS C function same_tnumber_tnumber. -func SameTnumberTnumber(temp1 *Temporal, temp2 *Temporal) bool { +func SameTnumberTnumber(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.same_tnumber_tnumber(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SameTstzspanTemporal wraps MEOS C function same_tstzspan_temporal. -func SameTstzspanTemporal(s *Span, temp *Temporal) bool { +func SameTstzspanTemporal(s *Span, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.same_tstzspan_temporal(s._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterTBOXTnumber wraps MEOS C function after_tbox_tnumber. -func AfterTBOXTnumber(box *TBox, temp *Temporal) bool { +func AfterTBOXTnumber(box *TBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_tbox_tnumber(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterTemporalTstzspan wraps MEOS C function after_temporal_tstzspan. -func AfterTemporalTstzspan(temp *Temporal, s *Span) bool { +func AfterTemporalTstzspan(temp *Temporal, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_temporal_tstzspan(temp._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterTemporalTemporal wraps MEOS C function after_temporal_temporal. -func AfterTemporalTemporal(temp1 *Temporal, temp2 *Temporal) bool { +func AfterTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_temporal_temporal(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterTnumberTBOX wraps MEOS C function after_tnumber_tbox. -func AfterTnumberTBOX(temp *Temporal, box *TBox) bool { +func AfterTnumberTBOX(temp *Temporal, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_tnumber_tbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterTnumberTnumber wraps MEOS C function after_tnumber_tnumber. -func AfterTnumberTnumber(temp1 *Temporal, temp2 *Temporal) bool { +func AfterTnumberTnumber(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_tnumber_tnumber(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterTstzspanTemporal wraps MEOS C function after_tstzspan_temporal. -func AfterTstzspanTemporal(s *Span, temp *Temporal) bool { +func AfterTstzspanTemporal(s *Span, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_tstzspan_temporal(s._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeTBOXTnumber wraps MEOS C function before_tbox_tnumber. -func BeforeTBOXTnumber(box *TBox, temp *Temporal) bool { +func BeforeTBOXTnumber(box *TBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_tbox_tnumber(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeTemporalTstzspan wraps MEOS C function before_temporal_tstzspan. -func BeforeTemporalTstzspan(temp *Temporal, s *Span) bool { +func BeforeTemporalTstzspan(temp *Temporal, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_temporal_tstzspan(temp._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeTemporalTemporal wraps MEOS C function before_temporal_temporal. -func BeforeTemporalTemporal(temp1 *Temporal, temp2 *Temporal) bool { +func BeforeTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_temporal_temporal(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeTnumberTBOX wraps MEOS C function before_tnumber_tbox. -func BeforeTnumberTBOX(temp *Temporal, box *TBox) bool { +func BeforeTnumberTBOX(temp *Temporal, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_tnumber_tbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeTnumberTnumber wraps MEOS C function before_tnumber_tnumber. -func BeforeTnumberTnumber(temp1 *Temporal, temp2 *Temporal) bool { +func BeforeTnumberTnumber(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_tnumber_tnumber(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeTstzspanTemporal wraps MEOS C function before_tstzspan_temporal. -func BeforeTstzspanTemporal(s *Span, temp *Temporal) bool { +func BeforeTstzspanTemporal(s *Span, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_tstzspan_temporal(s._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftTBOXTnumber wraps MEOS C function left_tbox_tnumber. -func LeftTBOXTnumber(box *TBox, temp *Temporal) bool { +func LeftTBOXTnumber(box *TBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_tbox_tnumber(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftNumspanTnumber wraps MEOS C function left_numspan_tnumber. -func LeftNumspanTnumber(s *Span, temp *Temporal) bool { +func LeftNumspanTnumber(s *Span, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_numspan_tnumber(s._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftTnumberNumspan wraps MEOS C function left_tnumber_numspan. -func LeftTnumberNumspan(temp *Temporal, s *Span) bool { +func LeftTnumberNumspan(temp *Temporal, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_tnumber_numspan(temp._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftTnumberTBOX wraps MEOS C function left_tnumber_tbox. -func LeftTnumberTBOX(temp *Temporal, box *TBox) bool { +func LeftTnumberTBOX(temp *Temporal, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_tnumber_tbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftTnumberTnumber wraps MEOS C function left_tnumber_tnumber. -func LeftTnumberTnumber(temp1 *Temporal, temp2 *Temporal) bool { +func LeftTnumberTnumber(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_tnumber_tnumber(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterTBOXTnumber wraps MEOS C function overafter_tbox_tnumber. -func OverafterTBOXTnumber(box *TBox, temp *Temporal) bool { +func OverafterTBOXTnumber(box *TBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_tbox_tnumber(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterTemporalTstzspan wraps MEOS C function overafter_temporal_tstzspan. -func OverafterTemporalTstzspan(temp *Temporal, s *Span) bool { +func OverafterTemporalTstzspan(temp *Temporal, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_temporal_tstzspan(temp._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterTemporalTemporal wraps MEOS C function overafter_temporal_temporal. -func OverafterTemporalTemporal(temp1 *Temporal, temp2 *Temporal) bool { +func OverafterTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_temporal_temporal(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterTnumberTBOX wraps MEOS C function overafter_tnumber_tbox. -func OverafterTnumberTBOX(temp *Temporal, box *TBox) bool { +func OverafterTnumberTBOX(temp *Temporal, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_tnumber_tbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterTnumberTnumber wraps MEOS C function overafter_tnumber_tnumber. -func OverafterTnumberTnumber(temp1 *Temporal, temp2 *Temporal) bool { +func OverafterTnumberTnumber(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_tnumber_tnumber(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterTstzspanTemporal wraps MEOS C function overafter_tstzspan_temporal. -func OverafterTstzspanTemporal(s *Span, temp *Temporal) bool { +func OverafterTstzspanTemporal(s *Span, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_tstzspan_temporal(s._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeTBOXTnumber wraps MEOS C function overbefore_tbox_tnumber. -func OverbeforeTBOXTnumber(box *TBox, temp *Temporal) bool { +func OverbeforeTBOXTnumber(box *TBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_tbox_tnumber(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeTemporalTstzspan wraps MEOS C function overbefore_temporal_tstzspan. -func OverbeforeTemporalTstzspan(temp *Temporal, s *Span) bool { +func OverbeforeTemporalTstzspan(temp *Temporal, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_temporal_tstzspan(temp._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeTemporalTemporal wraps MEOS C function overbefore_temporal_temporal. -func OverbeforeTemporalTemporal(temp1 *Temporal, temp2 *Temporal) bool { +func OverbeforeTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_temporal_temporal(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeTnumberTBOX wraps MEOS C function overbefore_tnumber_tbox. -func OverbeforeTnumberTBOX(temp *Temporal, box *TBox) bool { +func OverbeforeTnumberTBOX(temp *Temporal, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_tnumber_tbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeTnumberTnumber wraps MEOS C function overbefore_tnumber_tnumber. -func OverbeforeTnumberTnumber(temp1 *Temporal, temp2 *Temporal) bool { +func OverbeforeTnumberTnumber(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_tnumber_tnumber(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeTstzspanTemporal wraps MEOS C function overbefore_tstzspan_temporal. -func OverbeforeTstzspanTemporal(s *Span, temp *Temporal) bool { +func OverbeforeTstzspanTemporal(s *Span, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_tstzspan_temporal(s._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftNumspanTnumber wraps MEOS C function overleft_numspan_tnumber. -func OverleftNumspanTnumber(s *Span, temp *Temporal) bool { +func OverleftNumspanTnumber(s *Span, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_numspan_tnumber(s._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftTBOXTnumber wraps MEOS C function overleft_tbox_tnumber. -func OverleftTBOXTnumber(box *TBox, temp *Temporal) bool { +func OverleftTBOXTnumber(box *TBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_tbox_tnumber(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftTnumberNumspan wraps MEOS C function overleft_tnumber_numspan. -func OverleftTnumberNumspan(temp *Temporal, s *Span) bool { +func OverleftTnumberNumspan(temp *Temporal, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_tnumber_numspan(temp._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftTnumberTBOX wraps MEOS C function overleft_tnumber_tbox. -func OverleftTnumberTBOX(temp *Temporal, box *TBox) bool { +func OverleftTnumberTBOX(temp *Temporal, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_tnumber_tbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftTnumberTnumber wraps MEOS C function overleft_tnumber_tnumber. -func OverleftTnumberTnumber(temp1 *Temporal, temp2 *Temporal) bool { +func OverleftTnumberTnumber(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_tnumber_tnumber(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightNumspanTnumber wraps MEOS C function overright_numspan_tnumber. -func OverrightNumspanTnumber(s *Span, temp *Temporal) bool { +func OverrightNumspanTnumber(s *Span, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_numspan_tnumber(s._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightTBOXTnumber wraps MEOS C function overright_tbox_tnumber. -func OverrightTBOXTnumber(box *TBox, temp *Temporal) bool { +func OverrightTBOXTnumber(box *TBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_tbox_tnumber(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightTnumberNumspan wraps MEOS C function overright_tnumber_numspan. -func OverrightTnumberNumspan(temp *Temporal, s *Span) bool { +func OverrightTnumberNumspan(temp *Temporal, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_tnumber_numspan(temp._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightTnumberTBOX wraps MEOS C function overright_tnumber_tbox. -func OverrightTnumberTBOX(temp *Temporal, box *TBox) bool { +func OverrightTnumberTBOX(temp *Temporal, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_tnumber_tbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightTnumberTnumber wraps MEOS C function overright_tnumber_tnumber. -func OverrightTnumberTnumber(temp1 *Temporal, temp2 *Temporal) bool { +func OverrightTnumberTnumber(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_tnumber_tnumber(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightNumspanTnumber wraps MEOS C function right_numspan_tnumber. -func RightNumspanTnumber(s *Span, temp *Temporal) bool { +func RightNumspanTnumber(s *Span, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_numspan_tnumber(s._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightTBOXTnumber wraps MEOS C function right_tbox_tnumber. -func RightTBOXTnumber(box *TBox, temp *Temporal) bool { +func RightTBOXTnumber(box *TBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_tbox_tnumber(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightTnumberNumspan wraps MEOS C function right_tnumber_numspan. -func RightTnumberNumspan(temp *Temporal, s *Span) bool { +func RightTnumberNumspan(temp *Temporal, s *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_tnumber_numspan(temp._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightTnumberTBOX wraps MEOS C function right_tnumber_tbox. -func RightTnumberTBOX(temp *Temporal, box *TBox) bool { +func RightTnumberTBOX(temp *Temporal, box *TBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_tnumber_tbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightTnumberTnumber wraps MEOS C function right_tnumber_tnumber. -func RightTnumberTnumber(temp1 *Temporal, temp2 *Temporal) bool { +func RightTnumberTnumber(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_tnumber_tnumber(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TandBoolTbool wraps MEOS C function tand_bool_tbool. -func TandBoolTbool(b bool, temp *Temporal) *Temporal { +func TandBoolTbool(b bool, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tand_bool_tbool(C.bool(b), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TandTboolBool wraps MEOS C function tand_tbool_bool. -func TandTboolBool(temp *Temporal, b bool) *Temporal { +func TandTboolBool(temp *Temporal, b bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tand_tbool_bool(temp._inner, C.bool(b)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TandTboolTbool wraps MEOS C function tand_tbool_tbool. -func TandTboolTbool(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TandTboolTbool(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tand_tbool_tbool(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TboolWhenTrue wraps MEOS C function tbool_when_true. -func TboolWhenTrue(temp *Temporal) *SpanSet { +func TboolWhenTrue(temp *Temporal) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.tbool_when_true(temp._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // TnotTbool wraps MEOS C function tnot_tbool. -func TnotTbool(temp *Temporal) *Temporal { +func TnotTbool(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnot_tbool(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TorBoolTbool wraps MEOS C function tor_bool_tbool. -func TorBoolTbool(b bool, temp *Temporal) *Temporal { +func TorBoolTbool(b bool, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tor_bool_tbool(C.bool(b), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TorTboolBool wraps MEOS C function tor_tbool_bool. -func TorTboolBool(temp *Temporal, b bool) *Temporal { +func TorTboolBool(temp *Temporal, b bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tor_tbool_bool(temp._inner, C.bool(b)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TorTboolTbool wraps MEOS C function tor_tbool_tbool. -func TorTboolTbool(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TorTboolTbool(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tor_tbool_tbool(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // AddFloatTfloat wraps MEOS C function add_float_tfloat. -func AddFloatTfloat(d float64, tnumber *Temporal) *Temporal { +func AddFloatTfloat(d float64, tnumber *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.add_float_tfloat(C.double(d), tnumber._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // AddIntTint wraps MEOS C function add_int_tint. -func AddIntTint(i int, tnumber *Temporal) *Temporal { +func AddIntTint(i int, tnumber *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.add_int_tint(C.int(i), tnumber._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // AddTfloatFloat wraps MEOS C function add_tfloat_float. -func AddTfloatFloat(tnumber *Temporal, d float64) *Temporal { +func AddTfloatFloat(tnumber *Temporal, d float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.add_tfloat_float(tnumber._inner, C.double(d)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // AddTintInt wraps MEOS C function add_tint_int. -func AddTintInt(tnumber *Temporal, i int) *Temporal { +func AddTintInt(tnumber *Temporal, i int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.add_tint_int(tnumber._inner, C.int(i)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // AddBigintTbigint wraps MEOS C function add_bigint_tbigint. -func AddBigintTbigint(i int64, tnumber *Temporal) *Temporal { +func AddBigintTbigint(i int64, tnumber *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.add_bigint_tbigint(C.int64_t(i), tnumber._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // AddTbigintBigint wraps MEOS C function add_tbigint_bigint. -func AddTbigintBigint(tnumber *Temporal, i int64) *Temporal { +func AddTbigintBigint(tnumber *Temporal, i int64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.add_tbigint_bigint(tnumber._inner, C.int64_t(i)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // AddTnumberTnumber wraps MEOS C function add_tnumber_tnumber. -func AddTnumberTnumber(tnumber1 *Temporal, tnumber2 *Temporal) *Temporal { +func AddTnumberTnumber(tnumber1 *Temporal, tnumber2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.add_tnumber_tnumber(tnumber1._inner, tnumber2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // DivFloatTfloat wraps MEOS C function div_float_tfloat. -func DivFloatTfloat(d float64, tnumber *Temporal) *Temporal { +func DivFloatTfloat(d float64, tnumber *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.div_float_tfloat(C.double(d), tnumber._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // DivIntTint wraps MEOS C function div_int_tint. -func DivIntTint(i int, tnumber *Temporal) *Temporal { +func DivIntTint(i int, tnumber *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.div_int_tint(C.int(i), tnumber._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // DivTfloatFloat wraps MEOS C function div_tfloat_float. -func DivTfloatFloat(tnumber *Temporal, d float64) *Temporal { +func DivTfloatFloat(tnumber *Temporal, d float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.div_tfloat_float(tnumber._inner, C.double(d)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // DivTintInt wraps MEOS C function div_tint_int. -func DivTintInt(tnumber *Temporal, i int) *Temporal { +func DivTintInt(tnumber *Temporal, i int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.div_tint_int(tnumber._inner, C.int(i)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // DivBigintTbigint wraps MEOS C function div_bigint_tbigint. -func DivBigintTbigint(i int64, tnumber *Temporal) *Temporal { +func DivBigintTbigint(i int64, tnumber *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.div_bigint_tbigint(C.int64_t(i), tnumber._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // DivTbigintBigint wraps MEOS C function div_tbigint_bigint. -func DivTbigintBigint(tnumber *Temporal, i int64) *Temporal { +func DivTbigintBigint(tnumber *Temporal, i int64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.div_tbigint_bigint(tnumber._inner, C.int64_t(i)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // DivTnumberTnumber wraps MEOS C function div_tnumber_tnumber. -func DivTnumberTnumber(tnumber1 *Temporal, tnumber2 *Temporal) *Temporal { +func DivTnumberTnumber(tnumber1 *Temporal, tnumber2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.div_tnumber_tnumber(tnumber1._inner, tnumber2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // MulFloatTfloat wraps MEOS C function mul_float_tfloat. -func MulFloatTfloat(d float64, tnumber *Temporal) *Temporal { +func MulFloatTfloat(d float64, tnumber *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.mul_float_tfloat(C.double(d), tnumber._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // MulIntTint wraps MEOS C function mul_int_tint. -func MulIntTint(i int, tnumber *Temporal) *Temporal { +func MulIntTint(i int, tnumber *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.mul_int_tint(C.int(i), tnumber._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // MulTfloatFloat wraps MEOS C function mul_tfloat_float. -func MulTfloatFloat(tnumber *Temporal, d float64) *Temporal { +func MulTfloatFloat(tnumber *Temporal, d float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.mul_tfloat_float(tnumber._inner, C.double(d)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // MulTintInt wraps MEOS C function mul_tint_int. -func MulTintInt(tnumber *Temporal, i int) *Temporal { +func MulTintInt(tnumber *Temporal, i int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.mul_tint_int(tnumber._inner, C.int(i)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // MulBigintTbigint wraps MEOS C function mul_bigint_tbigint. -func MulBigintTbigint(i int64, tnumber *Temporal) *Temporal { +func MulBigintTbigint(i int64, tnumber *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.mul_bigint_tbigint(C.int64_t(i), tnumber._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // MulTbigintBigint wraps MEOS C function mul_tbigint_bigint. -func MulTbigintBigint(tnumber *Temporal, i int64) *Temporal { +func MulTbigintBigint(tnumber *Temporal, i int64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.mul_tbigint_bigint(tnumber._inner, C.int64_t(i)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // MulTnumberTnumber wraps MEOS C function mul_tnumber_tnumber. -func MulTnumberTnumber(tnumber1 *Temporal, tnumber2 *Temporal) *Temporal { +func MulTnumberTnumber(tnumber1 *Temporal, tnumber2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.mul_tnumber_tnumber(tnumber1._inner, tnumber2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // SubFloatTfloat wraps MEOS C function sub_float_tfloat. -func SubFloatTfloat(d float64, tnumber *Temporal) *Temporal { +func SubFloatTfloat(d float64, tnumber *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.sub_float_tfloat(C.double(d), tnumber._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // SubIntTint wraps MEOS C function sub_int_tint. -func SubIntTint(i int, tnumber *Temporal) *Temporal { +func SubIntTint(i int, tnumber *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.sub_int_tint(C.int(i), tnumber._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // SubTfloatFloat wraps MEOS C function sub_tfloat_float. -func SubTfloatFloat(tnumber *Temporal, d float64) *Temporal { +func SubTfloatFloat(tnumber *Temporal, d float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.sub_tfloat_float(tnumber._inner, C.double(d)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // SubTintInt wraps MEOS C function sub_tint_int. -func SubTintInt(tnumber *Temporal, i int) *Temporal { +func SubTintInt(tnumber *Temporal, i int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.sub_tint_int(tnumber._inner, C.int(i)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // SubBigintTbigint wraps MEOS C function sub_bigint_tbigint. -func SubBigintTbigint(i int64, tnumber *Temporal) *Temporal { +func SubBigintTbigint(i int64, tnumber *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.sub_bigint_tbigint(C.int64_t(i), tnumber._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // SubTbigintBigint wraps MEOS C function sub_tbigint_bigint. -func SubTbigintBigint(tnumber *Temporal, i int64) *Temporal { +func SubTbigintBigint(tnumber *Temporal, i int64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.sub_tbigint_bigint(tnumber._inner, C.int64_t(i)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // SubTnumberTnumber wraps MEOS C function sub_tnumber_tnumber. -func SubTnumberTnumber(tnumber1 *Temporal, tnumber2 *Temporal) *Temporal { +func SubTnumberTnumber(tnumber1 *Temporal, tnumber2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.sub_tnumber_tnumber(tnumber1._inner, tnumber2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalDerivative wraps MEOS C function temporal_derivative. -func TemporalDerivative(temp *Temporal) *Temporal { +func TemporalDerivative(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_derivative(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TfloatExp wraps MEOS C function tfloat_exp. -func TfloatExp(temp *Temporal) *Temporal { +func TfloatExp(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tfloat_exp(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TfloatLn wraps MEOS C function tfloat_ln. -func TfloatLn(temp *Temporal) *Temporal { +func TfloatLn(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tfloat_ln(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TfloatLog10 wraps MEOS C function tfloat_log10. -func TfloatLog10(temp *Temporal) *Temporal { +func TfloatLog10(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tfloat_log10(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TfloatSin wraps MEOS C function tfloat_sin. -func TfloatSin(temp *Temporal) *Temporal { +func TfloatSin(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tfloat_sin(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TfloatCos wraps MEOS C function tfloat_cos. -func TfloatCos(temp *Temporal) *Temporal { +func TfloatCos(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tfloat_cos(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TfloatTan wraps MEOS C function tfloat_tan. -func TfloatTan(temp *Temporal) *Temporal { +func TfloatTan(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tfloat_tan(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnumberAbs wraps MEOS C function tnumber_abs. -func TnumberAbs(temp *Temporal) *Temporal { +func TnumberAbs(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnumber_abs(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnumberTrend wraps MEOS C function tnumber_trend. -func TnumberTrend(temp *Temporal) *Temporal { +func TnumberTrend(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnumber_trend(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // FloatAngularDifference wraps MEOS C function float_angular_difference. -func FloatAngularDifference(degrees1 float64, degrees2 float64) float64 { +func FloatAngularDifference(degrees1 float64, degrees2 float64) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.float_angular_difference(C.double(degrees1), C.double(degrees2)) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TnumberAngularDifference wraps MEOS C function tnumber_angular_difference. -func TnumberAngularDifference(temp *Temporal) *Temporal { +func TnumberAngularDifference(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnumber_angular_difference(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnumberDeltaValue wraps MEOS C function tnumber_delta_value. -func TnumberDeltaValue(temp *Temporal) *Temporal { +func TnumberDeltaValue(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnumber_delta_value(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TextcatTextTtext wraps MEOS C function textcat_text_ttext. -func TextcatTextTtext(txt string, temp *Temporal) *Temporal { +func TextcatTextTtext(txt string, temp *Temporal) (_r0 *Temporal, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.textcat_text_ttext(_c_txt, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TextcatTtextText wraps MEOS C function textcat_ttext_text. -func TextcatTtextText(temp *Temporal, txt string) *Temporal { +func TextcatTtextText(temp *Temporal, txt string) (_r0 *Temporal, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.textcat_ttext_text(temp._inner, _c_txt) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TextcatTtextTtext wraps MEOS C function textcat_ttext_ttext. -func TextcatTtextTtext(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TextcatTtextTtext(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.textcat_ttext_ttext(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TtextInitcap wraps MEOS C function ttext_initcap. -func TtextInitcap(temp *Temporal) *Temporal { +func TtextInitcap(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.ttext_initcap(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TtextUpper wraps MEOS C function ttext_upper. -func TtextUpper(temp *Temporal) *Temporal { +func TtextUpper(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.ttext_upper(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TtextLower wraps MEOS C function ttext_lower. -func TtextLower(temp *Temporal) *Temporal { +func TtextLower(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.ttext_lower(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdistanceTfloatFloat wraps MEOS C function tdistance_tfloat_float. -func TdistanceTfloatFloat(temp *Temporal, d float64) *Temporal { +func TdistanceTfloatFloat(temp *Temporal, d float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdistance_tfloat_float(temp._inner, C.double(d)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdistanceTintInt wraps MEOS C function tdistance_tint_int. -func TdistanceTintInt(temp *Temporal, i int) *Temporal { +func TdistanceTintInt(temp *Temporal, i int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdistance_tint_int(temp._inner, C.int(i)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdistanceTnumberTnumber wraps MEOS C function tdistance_tnumber_tnumber. -func TdistanceTnumberTnumber(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TdistanceTnumberTnumber(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdistance_tnumber_tnumber(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // NadTboxfloatTboxfloat wraps MEOS C function nad_tboxfloat_tboxfloat. -func NadTboxfloatTboxfloat(box1 *TBox, box2 *TBox) float64 { +func NadTboxfloatTboxfloat(box1 *TBox, box2 *TBox) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_tboxfloat_tboxfloat(box1._inner, box2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NadTboxintTboxint wraps MEOS C function nad_tboxint_tboxint. -func NadTboxintTboxint(box1 *TBox, box2 *TBox) int { +func NadTboxintTboxint(box1 *TBox, box2 *TBox) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.nad_tboxint_tboxint(box1._inner, box2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // NadTfloatFloat wraps MEOS C function nad_tfloat_float. -func NadTfloatFloat(temp *Temporal, d float64) float64 { +func NadTfloatFloat(temp *Temporal, d float64) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_tfloat_float(temp._inner, C.double(d)) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NadTfloatTfloat wraps MEOS C function nad_tfloat_tfloat. -func NadTfloatTfloat(temp1 *Temporal, temp2 *Temporal) float64 { +func NadTfloatTfloat(temp1 *Temporal, temp2 *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_tfloat_tfloat(temp1._inner, temp2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NadTfloatTBOX wraps MEOS C function nad_tfloat_tbox. -func NadTfloatTBOX(temp *Temporal, box *TBox) float64 { +func NadTfloatTBOX(temp *Temporal, box *TBox) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_tfloat_tbox(temp._inner, box._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NadTbigintBigint wraps MEOS C function nad_tbigint_bigint. -func NadTbigintBigint(temp *Temporal, i int64) int64 { +func NadTbigintBigint(temp *Temporal, i int64) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.nad_tbigint_bigint(temp._inner, C.int64_t(i)) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // NadTbigintTBOX wraps MEOS C function nad_tbigint_tbox. -func NadTbigintTBOX(temp *Temporal, box *TBox) int64 { +func NadTbigintTBOX(temp *Temporal, box *TBox) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.nad_tbigint_tbox(temp._inner, box._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // NadTbigintTbigint wraps MEOS C function nad_tbigint_tbigint. -func NadTbigintTbigint(temp1 *Temporal, temp2 *Temporal) int64 { +func NadTbigintTbigint(temp1 *Temporal, temp2 *Temporal) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.nad_tbigint_tbigint(temp1._inner, temp2._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // NadTboxbigintTboxbigint wraps MEOS C function nad_tboxbigint_tboxbigint. -func NadTboxbigintTboxbigint(box1 *TBox, box2 *TBox) int64 { +func NadTboxbigintTboxbigint(box1 *TBox, box2 *TBox) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.nad_tboxbigint_tboxbigint(box1._inner, box2._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // NadTintInt wraps MEOS C function nad_tint_int. -func NadTintInt(temp *Temporal, i int) int { +func NadTintInt(temp *Temporal, i int) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.nad_tint_int(temp._inner, C.int(i)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // NadTintTBOX wraps MEOS C function nad_tint_tbox. -func NadTintTBOX(temp *Temporal, box *TBox) int { +func NadTintTBOX(temp *Temporal, box *TBox) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.nad_tint_tbox(temp._inner, box._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // NadTintTint wraps MEOS C function nad_tint_tint. -func NadTintTint(temp1 *Temporal, temp2 *Temporal) int { +func NadTintTint(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.nad_tint_tint(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TbigintTmaxTransfn wraps MEOS C function tbigint_tmax_transfn. -func TbigintTmaxTransfn(state *SkipList, temp *Temporal) *SkipList { +func TbigintTmaxTransfn(state *SkipList, temp *Temporal) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tbigint_tmax_transfn(state._inner, temp._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TbigintTmaxCombinefn wraps MEOS C function tbigint_tmax_combinefn. -func TbigintTmaxCombinefn(state1 *SkipList, state2 *SkipList) *SkipList { +func TbigintTmaxCombinefn(state1 *SkipList, state2 *SkipList) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tbigint_tmax_combinefn(state1._inner, state2._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TbigintTminTransfn wraps MEOS C function tbigint_tmin_transfn. -func TbigintTminTransfn(state *SkipList, temp *Temporal) *SkipList { +func TbigintTminTransfn(state *SkipList, temp *Temporal) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tbigint_tmin_transfn(state._inner, temp._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TbigintTminCombinefn wraps MEOS C function tbigint_tmin_combinefn. -func TbigintTminCombinefn(state1 *SkipList, state2 *SkipList) *SkipList { +func TbigintTminCombinefn(state1 *SkipList, state2 *SkipList) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tbigint_tmin_combinefn(state1._inner, state2._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TbigintTsumTransfn wraps MEOS C function tbigint_tsum_transfn. -func TbigintTsumTransfn(state *SkipList, temp *Temporal) *SkipList { +func TbigintTsumTransfn(state *SkipList, temp *Temporal) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tbigint_tsum_transfn(state._inner, temp._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TbigintTsumCombinefn wraps MEOS C function tbigint_tsum_combinefn. -func TbigintTsumCombinefn(state1 *SkipList, state2 *SkipList) *SkipList { +func TbigintTsumCombinefn(state1 *SkipList, state2 *SkipList) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tbigint_tsum_combinefn(state1._inner, state2._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TbigintWmaxTransfn wraps MEOS C function tbigint_wmax_transfn. -func TbigintWmaxTransfn(state *SkipList, temp *Temporal, interv *Interval) *SkipList { +func TbigintWmaxTransfn(state *SkipList, temp *Temporal, interv *Interval) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tbigint_wmax_transfn(state._inner, temp._inner, interv._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TbigintWminTransfn wraps MEOS C function tbigint_wmin_transfn. -func TbigintWminTransfn(state *SkipList, temp *Temporal, interv *Interval) *SkipList { +func TbigintWminTransfn(state *SkipList, temp *Temporal, interv *Interval) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tbigint_wmin_transfn(state._inner, temp._inner, interv._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TbigintWsumTransfn wraps MEOS C function tbigint_wsum_transfn. -func TbigintWsumTransfn(state *SkipList, temp *Temporal, interv *Interval) *SkipList { +func TbigintWsumTransfn(state *SkipList, temp *Temporal, interv *Interval) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tbigint_wsum_transfn(state._inner, temp._inner, interv._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TboolTandTransfn wraps MEOS C function tbool_tand_transfn. -func TboolTandTransfn(state *SkipList, temp *Temporal) *SkipList { +func TboolTandTransfn(state *SkipList, temp *Temporal) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tbool_tand_transfn(state._inner, temp._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TboolTandCombinefn wraps MEOS C function tbool_tand_combinefn. -func TboolTandCombinefn(state1 *SkipList, state2 *SkipList) *SkipList { +func TboolTandCombinefn(state1 *SkipList, state2 *SkipList) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tbool_tand_combinefn(state1._inner, state2._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TboolTorTransfn wraps MEOS C function tbool_tor_transfn. -func TboolTorTransfn(state *SkipList, temp *Temporal) *SkipList { +func TboolTorTransfn(state *SkipList, temp *Temporal) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tbool_tor_transfn(state._inner, temp._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TboolTorCombinefn wraps MEOS C function tbool_tor_combinefn. -func TboolTorCombinefn(state1 *SkipList, state2 *SkipList) *SkipList { +func TboolTorCombinefn(state1 *SkipList, state2 *SkipList) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tbool_tor_combinefn(state1._inner, state2._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TemporalExtentTransfn wraps MEOS C function temporal_extent_transfn. -func TemporalExtentTransfn(s *Span, temp *Temporal) *Span { +func TemporalExtentTransfn(s *Span, temp *Temporal) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.temporal_extent_transfn(s._inner, temp._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TemporalTaggFinalfn wraps MEOS C function temporal_tagg_finalfn. -func TemporalTaggFinalfn(state *SkipList) *Temporal { +func TemporalTaggFinalfn(state *SkipList) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_tagg_finalfn(state._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalTcountTransfn wraps MEOS C function temporal_tcount_transfn. -func TemporalTcountTransfn(state *SkipList, temp *Temporal) *SkipList { +func TemporalTcountTransfn(state *SkipList, temp *Temporal) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.temporal_tcount_transfn(state._inner, temp._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TemporalTcountCombinefn wraps MEOS C function temporal_tcount_combinefn. -func TemporalTcountCombinefn(state1 *SkipList, state2 *SkipList) *SkipList { +func TemporalTcountCombinefn(state1 *SkipList, state2 *SkipList) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.temporal_tcount_combinefn(state1._inner, state2._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TfloatTmaxTransfn wraps MEOS C function tfloat_tmax_transfn. -func TfloatTmaxTransfn(state *SkipList, temp *Temporal) *SkipList { +func TfloatTmaxTransfn(state *SkipList, temp *Temporal) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tfloat_tmax_transfn(state._inner, temp._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TfloatTmaxCombinefn wraps MEOS C function tfloat_tmax_combinefn. -func TfloatTmaxCombinefn(state1 *SkipList, state2 *SkipList) *SkipList { +func TfloatTmaxCombinefn(state1 *SkipList, state2 *SkipList) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tfloat_tmax_combinefn(state1._inner, state2._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TfloatTminTransfn wraps MEOS C function tfloat_tmin_transfn. -func TfloatTminTransfn(state *SkipList, temp *Temporal) *SkipList { +func TfloatTminTransfn(state *SkipList, temp *Temporal) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tfloat_tmin_transfn(state._inner, temp._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TfloatTminCombinefn wraps MEOS C function tfloat_tmin_combinefn. -func TfloatTminCombinefn(state1 *SkipList, state2 *SkipList) *SkipList { +func TfloatTminCombinefn(state1 *SkipList, state2 *SkipList) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tfloat_tmin_combinefn(state1._inner, state2._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TfloatTsumTransfn wraps MEOS C function tfloat_tsum_transfn. -func TfloatTsumTransfn(state *SkipList, temp *Temporal) *SkipList { +func TfloatTsumTransfn(state *SkipList, temp *Temporal) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tfloat_tsum_transfn(state._inner, temp._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TfloatTsumCombinefn wraps MEOS C function tfloat_tsum_combinefn. -func TfloatTsumCombinefn(state1 *SkipList, state2 *SkipList) *SkipList { +func TfloatTsumCombinefn(state1 *SkipList, state2 *SkipList) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tfloat_tsum_combinefn(state1._inner, state2._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TfloatWmaxTransfn wraps MEOS C function tfloat_wmax_transfn. -func TfloatWmaxTransfn(state *SkipList, temp *Temporal, interv *Interval) *SkipList { +func TfloatWmaxTransfn(state *SkipList, temp *Temporal, interv *Interval) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tfloat_wmax_transfn(state._inner, temp._inner, interv._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TfloatWminTransfn wraps MEOS C function tfloat_wmin_transfn. -func TfloatWminTransfn(state *SkipList, temp *Temporal, interv *Interval) *SkipList { +func TfloatWminTransfn(state *SkipList, temp *Temporal, interv *Interval) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tfloat_wmin_transfn(state._inner, temp._inner, interv._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TfloatWsumTransfn wraps MEOS C function tfloat_wsum_transfn. -func TfloatWsumTransfn(state *SkipList, temp *Temporal, interv *Interval) *SkipList { +func TfloatWsumTransfn(state *SkipList, temp *Temporal, interv *Interval) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tfloat_wsum_transfn(state._inner, temp._inner, interv._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TimestamptzTcountTransfn wraps MEOS C function timestamptz_tcount_transfn. -func TimestamptzTcountTransfn(state *SkipList, t int64) *SkipList { +func TimestamptzTcountTransfn(state *SkipList, t int64) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.timestamptz_tcount_transfn(state._inner, C.TimestampTz(t)) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TintTmaxTransfn wraps MEOS C function tint_tmax_transfn. -func TintTmaxTransfn(state *SkipList, temp *Temporal) *SkipList { +func TintTmaxTransfn(state *SkipList, temp *Temporal) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tint_tmax_transfn(state._inner, temp._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TintTmaxCombinefn wraps MEOS C function tint_tmax_combinefn. -func TintTmaxCombinefn(state1 *SkipList, state2 *SkipList) *SkipList { +func TintTmaxCombinefn(state1 *SkipList, state2 *SkipList) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tint_tmax_combinefn(state1._inner, state2._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TintTminTransfn wraps MEOS C function tint_tmin_transfn. -func TintTminTransfn(state *SkipList, temp *Temporal) *SkipList { +func TintTminTransfn(state *SkipList, temp *Temporal) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tint_tmin_transfn(state._inner, temp._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TintTminCombinefn wraps MEOS C function tint_tmin_combinefn. -func TintTminCombinefn(state1 *SkipList, state2 *SkipList) *SkipList { +func TintTminCombinefn(state1 *SkipList, state2 *SkipList) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tint_tmin_combinefn(state1._inner, state2._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TintTsumTransfn wraps MEOS C function tint_tsum_transfn. -func TintTsumTransfn(state *SkipList, temp *Temporal) *SkipList { +func TintTsumTransfn(state *SkipList, temp *Temporal) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tint_tsum_transfn(state._inner, temp._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TintTsumCombinefn wraps MEOS C function tint_tsum_combinefn. -func TintTsumCombinefn(state1 *SkipList, state2 *SkipList) *SkipList { +func TintTsumCombinefn(state1 *SkipList, state2 *SkipList) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tint_tsum_combinefn(state1._inner, state2._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TintWmaxTransfn wraps MEOS C function tint_wmax_transfn. -func TintWmaxTransfn(state *SkipList, temp *Temporal, interv *Interval) *SkipList { +func TintWmaxTransfn(state *SkipList, temp *Temporal, interv *Interval) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tint_wmax_transfn(state._inner, temp._inner, interv._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TintWminTransfn wraps MEOS C function tint_wmin_transfn. -func TintWminTransfn(state *SkipList, temp *Temporal, interv *Interval) *SkipList { +func TintWminTransfn(state *SkipList, temp *Temporal, interv *Interval) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tint_wmin_transfn(state._inner, temp._inner, interv._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TintWsumTransfn wraps MEOS C function tint_wsum_transfn. -func TintWsumTransfn(state *SkipList, temp *Temporal, interv *Interval) *SkipList { +func TintWsumTransfn(state *SkipList, temp *Temporal, interv *Interval) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tint_wsum_transfn(state._inner, temp._inner, interv._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TnumberExtentTransfn wraps MEOS C function tnumber_extent_transfn. -func TnumberExtentTransfn(box *TBox, temp *Temporal) *TBox { +func TnumberExtentTransfn(box *TBox, temp *Temporal) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tnumber_extent_transfn(box._inner, temp._inner) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TnumberTavgFinalfn wraps MEOS C function tnumber_tavg_finalfn. -func TnumberTavgFinalfn(state *SkipList) *Temporal { +func TnumberTavgFinalfn(state *SkipList) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnumber_tavg_finalfn(state._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnumberTavgTransfn wraps MEOS C function tnumber_tavg_transfn. -func TnumberTavgTransfn(state *SkipList, temp *Temporal) *SkipList { +func TnumberTavgTransfn(state *SkipList, temp *Temporal) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tnumber_tavg_transfn(state._inner, temp._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TnumberTavgCombinefn wraps MEOS C function tnumber_tavg_combinefn. -func TnumberTavgCombinefn(state1 *SkipList, state2 *SkipList) *SkipList { +func TnumberTavgCombinefn(state1 *SkipList, state2 *SkipList) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tnumber_tavg_combinefn(state1._inner, state2._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TnumberWavgTransfn wraps MEOS C function tnumber_wavg_transfn. -func TnumberWavgTransfn(state *SkipList, temp *Temporal, interv *Interval) *SkipList { +func TnumberWavgTransfn(state *SkipList, temp *Temporal, interv *Interval) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tnumber_wavg_transfn(state._inner, temp._inner, interv._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TstzsetTcountTransfn wraps MEOS C function tstzset_tcount_transfn. -func TstzsetTcountTransfn(state *SkipList, s *Set) *SkipList { +func TstzsetTcountTransfn(state *SkipList, s *Set) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tstzset_tcount_transfn(state._inner, s._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TstzspanTcountTransfn wraps MEOS C function tstzspan_tcount_transfn. -func TstzspanTcountTransfn(state *SkipList, s *Span) *SkipList { +func TstzspanTcountTransfn(state *SkipList, s *Span) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tstzspan_tcount_transfn(state._inner, s._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TstzspansetTcountTransfn wraps MEOS C function tstzspanset_tcount_transfn. -func TstzspansetTcountTransfn(state *SkipList, ss *SpanSet) *SkipList { +func TstzspansetTcountTransfn(state *SkipList, ss *SpanSet) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tstzspanset_tcount_transfn(state._inner, ss._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TemporalMergeTransfn wraps MEOS C function temporal_merge_transfn. -func TemporalMergeTransfn(state *SkipList, temp *Temporal) *SkipList { +func TemporalMergeTransfn(state *SkipList, temp *Temporal) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.temporal_merge_transfn(state._inner, temp._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TemporalMergeCombinefn wraps MEOS C function temporal_merge_combinefn. -func TemporalMergeCombinefn(state1 *SkipList, state2 *SkipList) *SkipList { +func TemporalMergeCombinefn(state1 *SkipList, state2 *SkipList) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.temporal_merge_combinefn(state1._inner, state2._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TtextTmaxTransfn wraps MEOS C function ttext_tmax_transfn. -func TtextTmaxTransfn(state *SkipList, temp *Temporal) *SkipList { +func TtextTmaxTransfn(state *SkipList, temp *Temporal) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.ttext_tmax_transfn(state._inner, temp._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TtextTmaxCombinefn wraps MEOS C function ttext_tmax_combinefn. -func TtextTmaxCombinefn(state1 *SkipList, state2 *SkipList) *SkipList { +func TtextTmaxCombinefn(state1 *SkipList, state2 *SkipList) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.ttext_tmax_combinefn(state1._inner, state2._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TtextTminTransfn wraps MEOS C function ttext_tmin_transfn. -func TtextTminTransfn(state *SkipList, temp *Temporal) *SkipList { +func TtextTminTransfn(state *SkipList, temp *Temporal) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.ttext_tmin_transfn(state._inner, temp._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TtextTminCombinefn wraps MEOS C function ttext_tmin_combinefn. -func TtextTminCombinefn(state1 *SkipList, state2 *SkipList) *SkipList { +func TtextTminCombinefn(state1 *SkipList, state2 *SkipList) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.ttext_tmin_combinefn(state1._inner, state2._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TemporalSimplifyDp wraps MEOS C function temporal_simplify_dp. -func TemporalSimplifyDp(temp *Temporal, dist float64, synchronized bool) *Temporal { +func TemporalSimplifyDp(temp *Temporal, dist float64, synchronized bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_simplify_dp(temp._inner, C.double(dist), C.bool(synchronized)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalSimplifyMaxDist wraps MEOS C function temporal_simplify_max_dist. -func TemporalSimplifyMaxDist(temp *Temporal, dist float64, synchronized bool) *Temporal { +func TemporalSimplifyMaxDist(temp *Temporal, dist float64, synchronized bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_simplify_max_dist(temp._inner, C.double(dist), C.bool(synchronized)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalSimplifyMinDist wraps MEOS C function temporal_simplify_min_dist. -func TemporalSimplifyMinDist(temp *Temporal, dist float64) *Temporal { +func TemporalSimplifyMinDist(temp *Temporal, dist float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_simplify_min_dist(temp._inner, C.double(dist)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalSimplifyMinTdelta wraps MEOS C function temporal_simplify_min_tdelta. -func TemporalSimplifyMinTdelta(temp *Temporal, mint *Interval) *Temporal { +func TemporalSimplifyMinTdelta(temp *Temporal, mint *Interval) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_simplify_min_tdelta(temp._inner, mint._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalTprecision wraps MEOS C function temporal_tprecision. -func TemporalTprecision(temp *Temporal, duration *Interval, origin int64) *Temporal { +func TemporalTprecision(temp *Temporal, duration *Interval, origin int64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_tprecision(temp._inner, duration._inner, C.TimestampTz(origin)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalTsample wraps MEOS C function temporal_tsample. -func TemporalTsample(temp *Temporal, duration *Interval, origin int64, interp Interpolation) *Temporal { +func TemporalTsample(temp *Temporal, duration *Interval, origin int64, interp Interpolation) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_tsample(temp._inner, duration._inner, C.TimestampTz(origin), C.interpType(interp)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalDyntimewarpDistance wraps MEOS C function temporal_dyntimewarp_distance. -func TemporalDyntimewarpDistance(temp1 *Temporal, temp2 *Temporal) float64 { +func TemporalDyntimewarpDistance(temp1 *Temporal, temp2 *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.temporal_dyntimewarp_distance(temp1._inner, temp2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TemporalDyntimewarpPath wraps MEOS C function temporal_dyntimewarp_path. -func TemporalDyntimewarpPath(temp1 *Temporal, temp2 *Temporal, count unsafe.Pointer) *Match { +func TemporalDyntimewarpPath(temp1 *Temporal, temp2 *Temporal, count unsafe.Pointer) (_r0 *Match, _err error) { + C.meos_errno_reset() _cret := C.temporal_dyntimewarp_path(temp1._inner, temp2._inner, (*C.int)(unsafe.Pointer(count))) - return &Match{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Match{_inner: _cret}, nil } // TemporalFrechetDistance wraps MEOS C function temporal_frechet_distance. -func TemporalFrechetDistance(temp1 *Temporal, temp2 *Temporal) float64 { +func TemporalFrechetDistance(temp1 *Temporal, temp2 *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.temporal_frechet_distance(temp1._inner, temp2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TemporalFrechetPath wraps MEOS C function temporal_frechet_path. -func TemporalFrechetPath(temp1 *Temporal, temp2 *Temporal, count unsafe.Pointer) *Match { +func TemporalFrechetPath(temp1 *Temporal, temp2 *Temporal, count unsafe.Pointer) (_r0 *Match, _err error) { + C.meos_errno_reset() _cret := C.temporal_frechet_path(temp1._inner, temp2._inner, (*C.int)(unsafe.Pointer(count))) - return &Match{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Match{_inner: _cret}, nil } // TemporalHausdorffDistance wraps MEOS C function temporal_hausdorff_distance. -func TemporalHausdorffDistance(temp1 *Temporal, temp2 *Temporal) float64 { +func TemporalHausdorffDistance(temp1 *Temporal, temp2 *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.temporal_hausdorff_distance(temp1._inner, temp2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TemporalAverageHausdorffDistance wraps MEOS C function temporal_average_hausdorff_distance. -func TemporalAverageHausdorffDistance(temp1 *Temporal, temp2 *Temporal) float64 { +func TemporalAverageHausdorffDistance(temp1 *Temporal, temp2 *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.temporal_average_hausdorff_distance(temp1._inner, temp2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TemporalLcssDistance wraps MEOS C function temporal_lcss_distance. -func TemporalLcssDistance(temp1 *Temporal, temp2 *Temporal, epsilon float64) float64 { +func TemporalLcssDistance(temp1 *Temporal, temp2 *Temporal, epsilon float64) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.temporal_lcss_distance(temp1._inner, temp2._inner, C.double(epsilon)) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TemporalExtKalmanFilter wraps MEOS C function temporal_ext_kalman_filter. -func TemporalExtKalmanFilter(temp *Temporal, gate float64, q float64, variance float64, to_drop bool) *Temporal { +func TemporalExtKalmanFilter(temp *Temporal, gate float64, q float64, variance float64, to_drop bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_ext_kalman_filter(temp._inner, C.double(gate), C.double(q), C.double(variance), C.bool(to_drop)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalTimeBins wraps MEOS C function temporal_time_bins. -func TemporalTimeBins(temp *Temporal, duration *Interval, origin int64, count unsafe.Pointer) *Span { +func TemporalTimeBins(temp *Temporal, duration *Interval, origin int64, count unsafe.Pointer) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.temporal_time_bins(temp._inner, duration._inner, C.TimestampTz(origin), (*C.int)(unsafe.Pointer(count))) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TemporalTimeSplit wraps MEOS C function temporal_time_split. -func TemporalTimeSplit(temp *Temporal, duration *Interval, torigin int64, bins unsafe.Pointer, count unsafe.Pointer) unsafe.Pointer { +func TemporalTimeSplit(temp *Temporal, duration *Interval, torigin int64, bins unsafe.Pointer, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.temporal_time_split(temp._inner, duration._inner, C.TimestampTz(torigin), (**C.TimestampTz)(unsafe.Pointer(bins)), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TfloatTimeBoxes wraps MEOS C function tfloat_time_boxes. -func TfloatTimeBoxes(temp *Temporal, duration *Interval, torigin int64, count unsafe.Pointer) *TBox { +func TfloatTimeBoxes(temp *Temporal, duration *Interval, torigin int64, count unsafe.Pointer) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tfloat_time_boxes(temp._inner, duration._inner, C.TimestampTz(torigin), (*C.int)(unsafe.Pointer(count))) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TfloatValueBins wraps MEOS C function tfloat_value_bins. -func TfloatValueBins(temp *Temporal, vsize float64, vorigin float64, count unsafe.Pointer) *Span { +func TfloatValueBins(temp *Temporal, vsize float64, vorigin float64, count unsafe.Pointer) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.tfloat_value_bins(temp._inner, C.double(vsize), C.double(vorigin), (*C.int)(unsafe.Pointer(count))) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TfloatValueBoxes wraps MEOS C function tfloat_value_boxes. -func TfloatValueBoxes(temp *Temporal, vsize float64, vorigin float64, count unsafe.Pointer) *TBox { +func TfloatValueBoxes(temp *Temporal, vsize float64, vorigin float64, count unsafe.Pointer) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tfloat_value_boxes(temp._inner, C.double(vsize), C.double(vorigin), (*C.int)(unsafe.Pointer(count))) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TfloatValueSplit wraps MEOS C function tfloat_value_split. -func TfloatValueSplit(temp *Temporal, size float64, origin float64, bins unsafe.Pointer, count unsafe.Pointer) unsafe.Pointer { +func TfloatValueSplit(temp *Temporal, size float64, origin float64, bins unsafe.Pointer, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tfloat_value_split(temp._inner, C.double(size), C.double(origin), (**C.double)(unsafe.Pointer(bins)), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TfloatValueTimeBoxes wraps MEOS C function tfloat_value_time_boxes. -func TfloatValueTimeBoxes(temp *Temporal, vsize float64, duration *Interval, vorigin float64, torigin int64, count unsafe.Pointer) *TBox { +func TfloatValueTimeBoxes(temp *Temporal, vsize float64, duration *Interval, vorigin float64, torigin int64, count unsafe.Pointer) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tfloat_value_time_boxes(temp._inner, C.double(vsize), duration._inner, C.double(vorigin), C.TimestampTz(torigin), (*C.int)(unsafe.Pointer(count))) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TfloatValueTimeSplit wraps MEOS C function tfloat_value_time_split. -func TfloatValueTimeSplit(temp *Temporal, vsize float64, duration *Interval, vorigin float64, torigin int64, value_bins unsafe.Pointer, time_bins unsafe.Pointer, count unsafe.Pointer) unsafe.Pointer { +func TfloatValueTimeSplit(temp *Temporal, vsize float64, duration *Interval, vorigin float64, torigin int64, value_bins unsafe.Pointer, time_bins unsafe.Pointer, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tfloat_value_time_split(temp._inner, C.double(vsize), duration._inner, C.double(vorigin), C.TimestampTz(torigin), (**C.double)(unsafe.Pointer(value_bins)), (**C.TimestampTz)(unsafe.Pointer(time_bins)), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TfloatboxTimeTiles wraps MEOS C function tfloatbox_time_tiles. -func TfloatboxTimeTiles(box *TBox, duration *Interval, torigin int64, count unsafe.Pointer) *TBox { +func TfloatboxTimeTiles(box *TBox, duration *Interval, torigin int64, count unsafe.Pointer) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tfloatbox_time_tiles(box._inner, duration._inner, C.TimestampTz(torigin), (*C.int)(unsafe.Pointer(count))) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TfloatboxValueTiles wraps MEOS C function tfloatbox_value_tiles. -func TfloatboxValueTiles(box *TBox, vsize float64, vorigin float64, count unsafe.Pointer) *TBox { +func TfloatboxValueTiles(box *TBox, vsize float64, vorigin float64, count unsafe.Pointer) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tfloatbox_value_tiles(box._inner, C.double(vsize), C.double(vorigin), (*C.int)(unsafe.Pointer(count))) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TfloatboxValueTimeTiles wraps MEOS C function tfloatbox_value_time_tiles. -func TfloatboxValueTimeTiles(box *TBox, vsize float64, duration *Interval, vorigin float64, torigin int64, count unsafe.Pointer) *TBox { +func TfloatboxValueTimeTiles(box *TBox, vsize float64, duration *Interval, vorigin float64, torigin int64, count unsafe.Pointer) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tfloatbox_value_time_tiles(box._inner, C.double(vsize), duration._inner, C.double(vorigin), C.TimestampTz(torigin), (*C.int)(unsafe.Pointer(count))) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TintTimeBoxes wraps MEOS C function tint_time_boxes. -func TintTimeBoxes(temp *Temporal, duration *Interval, torigin int64, count unsafe.Pointer) *TBox { +func TintTimeBoxes(temp *Temporal, duration *Interval, torigin int64, count unsafe.Pointer) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tint_time_boxes(temp._inner, duration._inner, C.TimestampTz(torigin), (*C.int)(unsafe.Pointer(count))) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TintValueBins wraps MEOS C function tint_value_bins. -func TintValueBins(temp *Temporal, vsize int, vorigin int, count unsafe.Pointer) *Span { +func TintValueBins(temp *Temporal, vsize int, vorigin int, count unsafe.Pointer) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.tint_value_bins(temp._inner, C.int(vsize), C.int(vorigin), (*C.int)(unsafe.Pointer(count))) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TintValueBoxes wraps MEOS C function tint_value_boxes. -func TintValueBoxes(temp *Temporal, vsize int, vorigin int, count unsafe.Pointer) *TBox { +func TintValueBoxes(temp *Temporal, vsize int, vorigin int, count unsafe.Pointer) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tint_value_boxes(temp._inner, C.int(vsize), C.int(vorigin), (*C.int)(unsafe.Pointer(count))) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TintValueSplit wraps MEOS C function tint_value_split. -func TintValueSplit(temp *Temporal, vsize int, vorigin int, bins unsafe.Pointer, count unsafe.Pointer) unsafe.Pointer { +func TintValueSplit(temp *Temporal, vsize int, vorigin int, bins unsafe.Pointer, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tint_value_split(temp._inner, C.int(vsize), C.int(vorigin), (**C.int)(unsafe.Pointer(bins)), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TintValueTimeBoxes wraps MEOS C function tint_value_time_boxes. -func TintValueTimeBoxes(temp *Temporal, vsize int, duration *Interval, vorigin int, torigin int64, count unsafe.Pointer) *TBox { +func TintValueTimeBoxes(temp *Temporal, vsize int, duration *Interval, vorigin int, torigin int64, count unsafe.Pointer) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tint_value_time_boxes(temp._inner, C.int(vsize), duration._inner, C.int(vorigin), C.TimestampTz(torigin), (*C.int)(unsafe.Pointer(count))) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TintValueTimeSplit wraps MEOS C function tint_value_time_split. -func TintValueTimeSplit(temp *Temporal, size int, duration *Interval, vorigin int, torigin int64, value_bins unsafe.Pointer, time_bins unsafe.Pointer, count unsafe.Pointer) unsafe.Pointer { +func TintValueTimeSplit(temp *Temporal, size int, duration *Interval, vorigin int, torigin int64, value_bins unsafe.Pointer, time_bins unsafe.Pointer, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tint_value_time_split(temp._inner, C.int(size), duration._inner, C.int(vorigin), C.TimestampTz(torigin), (**C.int)(unsafe.Pointer(value_bins)), (**C.TimestampTz)(unsafe.Pointer(time_bins)), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TintboxTimeTiles wraps MEOS C function tintbox_time_tiles. -func TintboxTimeTiles(box *TBox, duration *Interval, torigin int64, count unsafe.Pointer) *TBox { +func TintboxTimeTiles(box *TBox, duration *Interval, torigin int64, count unsafe.Pointer) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tintbox_time_tiles(box._inner, duration._inner, C.TimestampTz(torigin), (*C.int)(unsafe.Pointer(count))) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TintboxValueTiles wraps MEOS C function tintbox_value_tiles. -func TintboxValueTiles(box *TBox, xsize int, xorigin int, count unsafe.Pointer) *TBox { +func TintboxValueTiles(box *TBox, xsize int, xorigin int, count unsafe.Pointer) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tintbox_value_tiles(box._inner, C.int(xsize), C.int(xorigin), (*C.int)(unsafe.Pointer(count))) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } // TintboxValueTimeTiles wraps MEOS C function tintbox_value_time_tiles. -func TintboxValueTimeTiles(box *TBox, xsize int, duration *Interval, xorigin int, torigin int64, count unsafe.Pointer) *TBox { +func TintboxValueTimeTiles(box *TBox, xsize int, duration *Interval, xorigin int, torigin int64, count unsafe.Pointer) (_r0 *TBox, _err error) { + C.meos_errno_reset() _cret := C.tintbox_value_time_tiles(box._inner, C.int(xsize), duration._inner, C.int(xorigin), C.TimestampTz(torigin), (*C.int)(unsafe.Pointer(count))) - return &TBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TBox{_inner: _cret}, nil } diff --git a/functions/meos_meos_catalog.go b/functions/meos_meos_catalog.go index cab1e2b..8d510f8 100644 --- a/functions/meos_meos_catalog.go +++ b/functions/meos_meos_catalog.go @@ -86,562 +86,878 @@ import ( var _ = unsafe.Pointer(nil) // TemptypeSubtype wraps MEOS C function temptype_subtype. -func TemptypeSubtype(subtype TempSubtype) bool { +func TemptypeSubtype(subtype TempSubtype) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.temptype_subtype(C.tempSubtype(subtype)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TemptypeSubtypeAll wraps MEOS C function temptype_subtype_all. -func TemptypeSubtypeAll(subtype TempSubtype) bool { +func TemptypeSubtypeAll(subtype TempSubtype) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.temptype_subtype_all(C.tempSubtype(subtype)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TempsubtypeName wraps MEOS C function tempsubtype_name. -func TempsubtypeName(subtype TempSubtype) string { +func TempsubtypeName(subtype TempSubtype) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.tempsubtype_name(C.tempSubtype(subtype)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TempsubtypeFromString wraps MEOS C function tempsubtype_from_string. -func TempsubtypeFromString(str string, subtype unsafe.Pointer) bool { +func TempsubtypeFromString(str string, subtype unsafe.Pointer) (_r0 bool, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tempsubtype_from_string(_c_str, (*C.int16)(unsafe.Pointer(subtype))) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // MeosoperName wraps MEOS C function meosoper_name. -func MeosoperName(oper MeosOper) string { +func MeosoperName(oper MeosOper) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.meosoper_name(C.MeosOper(oper)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // MeosoperFromString wraps MEOS C function meosoper_from_string. -func MeosoperFromString(name string) MeosOper { +func MeosoperFromString(name string) (_r0 MeosOper, _err error) { _c_name := C.CString(name) defer C.free(unsafe.Pointer(_c_name)) + C.meos_errno_reset() _cret := C.meosoper_from_string(_c_name) - return MeosOper(_cret) + if _err = meosError(); _err != nil { + return + } + return MeosOper(_cret), nil } // InterptypeName wraps MEOS C function interptype_name. -func InterptypeName(interp Interpolation) string { +func InterptypeName(interp Interpolation) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.interptype_name(C.interpType(interp)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // InterptypeFromString wraps MEOS C function interptype_from_string. -func InterptypeFromString(interp_str string) Interpolation { +func InterptypeFromString(interp_str string) (_r0 Interpolation, _err error) { _c_interp_str := C.CString(interp_str) defer C.free(unsafe.Pointer(_c_interp_str)) + C.meos_errno_reset() _cret := C.interptype_from_string(_c_interp_str) - return Interpolation(_cret) + if _err = meosError(); _err != nil { + return + } + return Interpolation(_cret), nil } // MeosTypeofHexwkb wraps MEOS C function meos_typeof_hexwkb. -func MeosTypeofHexwkb(hexwkb string) MeosType { +func MeosTypeofHexwkb(hexwkb string) (_r0 MeosType, _err error) { _c_hexwkb := C.CString(hexwkb) defer C.free(unsafe.Pointer(_c_hexwkb)) + C.meos_errno_reset() _cret := C.meos_typeof_hexwkb(_c_hexwkb) - return MeosType(_cret) + if _err = meosError(); _err != nil { + return + } + return MeosType(_cret), nil } // MeostypeName wraps MEOS C function meostype_name. -func MeostypeName(type_ MeosType) string { +func MeostypeName(type_ MeosType) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.meostype_name(C.MeosType(type_)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TemptypeBasetype wraps MEOS C function temptype_basetype. -func TemptypeBasetype(type_ MeosType) MeosType { +func TemptypeBasetype(type_ MeosType) (_r0 MeosType, _err error) { + C.meos_errno_reset() _cret := C.temptype_basetype(C.MeosType(type_)) - return MeosType(_cret) + if _err = meosError(); _err != nil { + return + } + return MeosType(_cret), nil } // SettypeBasetype wraps MEOS C function settype_basetype. -func SettypeBasetype(type_ MeosType) MeosType { +func SettypeBasetype(type_ MeosType) (_r0 MeosType, _err error) { + C.meos_errno_reset() _cret := C.settype_basetype(C.MeosType(type_)) - return MeosType(_cret) + if _err = meosError(); _err != nil { + return + } + return MeosType(_cret), nil } // SpantypeBasetype wraps MEOS C function spantype_basetype. -func SpantypeBasetype(type_ MeosType) MeosType { +func SpantypeBasetype(type_ MeosType) (_r0 MeosType, _err error) { + C.meos_errno_reset() _cret := C.spantype_basetype(C.MeosType(type_)) - return MeosType(_cret) + if _err = meosError(); _err != nil { + return + } + return MeosType(_cret), nil } // SpantypeSpansettype wraps MEOS C function spantype_spansettype. -func SpantypeSpansettype(type_ MeosType) MeosType { +func SpantypeSpansettype(type_ MeosType) (_r0 MeosType, _err error) { + C.meos_errno_reset() _cret := C.spantype_spansettype(C.MeosType(type_)) - return MeosType(_cret) + if _err = meosError(); _err != nil { + return + } + return MeosType(_cret), nil } // SpansettypeSpantype wraps MEOS C function spansettype_spantype. -func SpansettypeSpantype(type_ MeosType) MeosType { +func SpansettypeSpantype(type_ MeosType) (_r0 MeosType, _err error) { + C.meos_errno_reset() _cret := C.spansettype_spantype(C.MeosType(type_)) - return MeosType(_cret) + if _err = meosError(); _err != nil { + return + } + return MeosType(_cret), nil } // BasetypeSpantype wraps MEOS C function basetype_spantype. -func BasetypeSpantype(type_ MeosType) MeosType { +func BasetypeSpantype(type_ MeosType) (_r0 MeosType, _err error) { + C.meos_errno_reset() _cret := C.basetype_spantype(C.MeosType(type_)) - return MeosType(_cret) + if _err = meosError(); _err != nil { + return + } + return MeosType(_cret), nil } // BasetypeSettype wraps MEOS C function basetype_settype. -func BasetypeSettype(type_ MeosType) MeosType { +func BasetypeSettype(type_ MeosType) (_r0 MeosType, _err error) { + C.meos_errno_reset() _cret := C.basetype_settype(C.MeosType(type_)) - return MeosType(_cret) + if _err = meosError(); _err != nil { + return + } + return MeosType(_cret), nil } // TnumberBasetype wraps MEOS C function tnumber_basetype. -func TnumberBasetype(type_ MeosType) bool { +func TnumberBasetype(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tnumber_basetype(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // GeoBasetype wraps MEOS C function geo_basetype. -func GeoBasetype(type_ MeosType) bool { +func GeoBasetype(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.geo_basetype(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // MeosBasetype wraps MEOS C function meos_basetype. -func MeosBasetype(type_ MeosType) bool { +func MeosBasetype(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.meos_basetype(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AlphanumBasetype wraps MEOS C function alphanum_basetype. -func AlphanumBasetype(type_ MeosType) bool { +func AlphanumBasetype(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.alphanum_basetype(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AlphanumTemptype wraps MEOS C function alphanum_temptype. -func AlphanumTemptype(type_ MeosType) bool { +func AlphanumTemptype(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.alphanum_temptype(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TimeType wraps MEOS C function time_type. -func TimeType(type_ MeosType) bool { +func TimeType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.time_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SetBasetype wraps MEOS C function set_basetype. -func SetBasetype(type_ MeosType) bool { +func SetBasetype(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.set_basetype(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SetType wraps MEOS C function set_type. -func SetType(type_ MeosType) bool { +func SetType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.set_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // NumsetType wraps MEOS C function numset_type. -func NumsetType(type_ MeosType) bool { +func NumsetType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.numset_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // EnsureNumsetType wraps MEOS C function ensure_numset_type. -func EnsureNumsetType(type_ MeosType) bool { +func EnsureNumsetType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.ensure_numset_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TimesetType wraps MEOS C function timeset_type. -func TimesetType(type_ MeosType) bool { +func TimesetType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.timeset_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SetSpantype wraps MEOS C function set_spantype. -func SetSpantype(type_ MeosType) bool { +func SetSpantype(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.set_spantype(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // EnsureSetSpantype wraps MEOS C function ensure_set_spantype. -func EnsureSetSpantype(type_ MeosType) bool { +func EnsureSetSpantype(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.ensure_set_spantype(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AlphanumsetType wraps MEOS C function alphanumset_type. -func AlphanumsetType(settype MeosType) bool { +func AlphanumsetType(settype MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.alphanumset_type(C.MeosType(settype)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // GeosetType wraps MEOS C function geoset_type. -func GeosetType(type_ MeosType) bool { +func GeosetType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.geoset_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // EnsureGeosetType wraps MEOS C function ensure_geoset_type. -func EnsureGeosetType(type_ MeosType) bool { +func EnsureGeosetType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.ensure_geoset_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SpatialsetType wraps MEOS C function spatialset_type. -func SpatialsetType(type_ MeosType) bool { +func SpatialsetType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.spatialset_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // EnsureSpatialsetType wraps MEOS C function ensure_spatialset_type. -func EnsureSpatialsetType(type_ MeosType) bool { +func EnsureSpatialsetType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.ensure_spatialset_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PointcloudBasetype wraps MEOS C function pointcloud_basetype. -func PointcloudBasetype(type_ MeosType) bool { +func PointcloudBasetype(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pointcloud_basetype(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PointcloudsetType wraps MEOS C function pointcloudset_type. -func PointcloudsetType(type_ MeosType) bool { +func PointcloudsetType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pointcloudset_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TpointcloudTemptype wraps MEOS C function tpointcloud_temptype. -func TpointcloudTemptype(type_ MeosType) bool { +func TpointcloudTemptype(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tpointcloud_temptype(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // EnsureTpointcloudTemptype wraps MEOS C function ensure_tpointcloud_temptype. -func EnsureTpointcloudTemptype(type_ MeosType) bool { +func EnsureTpointcloudTemptype(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.ensure_tpointcloud_temptype(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SpanBasetype wraps MEOS C function span_basetype. -func SpanBasetype(type_ MeosType) bool { +func SpanBasetype(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.span_basetype(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SpanCanonBasetype wraps MEOS C function span_canon_basetype. -func SpanCanonBasetype(type_ MeosType) bool { +func SpanCanonBasetype(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.span_canon_basetype(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SpanType wraps MEOS C function span_type. -func SpanType(type_ MeosType) bool { +func SpanType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.span_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TypeSpanBbox wraps MEOS C function type_span_bbox. -func TypeSpanBbox(type_ MeosType) bool { +func TypeSpanBbox(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.type_span_bbox(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SpanTBOXType wraps MEOS C function span_tbox_type. -func SpanTBOXType(type_ MeosType) bool { +func SpanTBOXType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.span_tbox_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // EnsureSpanTBOXType wraps MEOS C function ensure_span_tbox_type. -func EnsureSpanTBOXType(type_ MeosType) bool { +func EnsureSpanTBOXType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.ensure_span_tbox_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // NumspanBasetype wraps MEOS C function numspan_basetype. -func NumspanBasetype(type_ MeosType) bool { +func NumspanBasetype(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.numspan_basetype(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // NumspanType wraps MEOS C function numspan_type. -func NumspanType(type_ MeosType) bool { +func NumspanType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.numspan_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // EnsureNumspanType wraps MEOS C function ensure_numspan_type. -func EnsureNumspanType(type_ MeosType) bool { +func EnsureNumspanType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.ensure_numspan_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TimespanBasetype wraps MEOS C function timespan_basetype. -func TimespanBasetype(type_ MeosType) bool { +func TimespanBasetype(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.timespan_basetype(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TimespanType wraps MEOS C function timespan_type. -func TimespanType(type_ MeosType) bool { +func TimespanType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.timespan_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SpansetType wraps MEOS C function spanset_type. -func SpansetType(type_ MeosType) bool { +func SpansetType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.spanset_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TimespansetType wraps MEOS C function timespanset_type. -func TimespansetType(type_ MeosType) bool { +func TimespansetType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.timespanset_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // EnsureTimespansetType wraps MEOS C function ensure_timespanset_type. -func EnsureTimespansetType(type_ MeosType) bool { +func EnsureTimespansetType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.ensure_timespanset_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TemporalType wraps MEOS C function temporal_type. -func TemporalType(type_ MeosType) bool { +func TemporalType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.temporal_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TemporalBasetype wraps MEOS C function temporal_basetype. -func TemporalBasetype(type_ MeosType) bool { +func TemporalBasetype(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.temporal_basetype(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TemptypeSupportsLinear wraps MEOS C function temptype_supports_linear. -func TemptypeSupportsLinear(type_ MeosType) bool { +func TemptypeSupportsLinear(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.temptype_supports_linear(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BasetypeByvalue wraps MEOS C function basetype_byvalue. -func BasetypeByvalue(type_ MeosType) bool { +func BasetypeByvalue(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.basetype_byvalue(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BasetypeVarlength wraps MEOS C function basetype_varlength. -func BasetypeVarlength(type_ MeosType) bool { +func BasetypeVarlength(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.basetype_varlength(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // MeostypeLength wraps MEOS C function meostype_length. -func MeostypeLength(type_ MeosType) int16 { +func MeostypeLength(type_ MeosType) (_r0 int16, _err error) { + C.meos_errno_reset() _cret := C.meostype_length(C.MeosType(type_)) - return int16(_cret) + if _err = meosError(); _err != nil { + return + } + return int16(_cret), nil } // TalphanumType wraps MEOS C function talphanum_type. -func TalphanumType(type_ MeosType) bool { +func TalphanumType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.talphanum_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TalphaType wraps MEOS C function talpha_type. -func TalphaType(type_ MeosType) bool { +func TalphaType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.talpha_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TnumberType wraps MEOS C function tnumber_type. -func TnumberType(type_ MeosType) bool { +func TnumberType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tnumber_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // EnsureTnumberType wraps MEOS C function ensure_tnumber_type. -func EnsureTnumberType(type_ MeosType) bool { +func EnsureTnumberType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.ensure_tnumber_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // EnsureTnumberBasetype wraps MEOS C function ensure_tnumber_basetype. -func EnsureTnumberBasetype(type_ MeosType) bool { +func EnsureTnumberBasetype(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.ensure_tnumber_basetype(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TnumberSpantype wraps MEOS C function tnumber_spantype. -func TnumberSpantype(type_ MeosType) bool { +func TnumberSpantype(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tnumber_spantype(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SpatialBasetype wraps MEOS C function spatial_basetype. -func SpatialBasetype(type_ MeosType) bool { +func SpatialBasetype(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.spatial_basetype(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TspatialType wraps MEOS C function tspatial_type. -func TspatialType(type_ MeosType) bool { +func TspatialType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tspatial_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // EnsureTspatialType wraps MEOS C function ensure_tspatial_type. -func EnsureTspatialType(type_ MeosType) bool { +func EnsureTspatialType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.ensure_tspatial_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TpointType wraps MEOS C function tpoint_type. -func TpointType(type_ MeosType) bool { +func TpointType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tpoint_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // EnsureTpointType wraps MEOS C function ensure_tpoint_type. -func EnsureTpointType(type_ MeosType) bool { +func EnsureTpointType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.ensure_tpoint_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TgeoType wraps MEOS C function tgeo_type. -func TgeoType(type_ MeosType) bool { +func TgeoType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tgeo_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // EnsureTgeoType wraps MEOS C function ensure_tgeo_type. -func EnsureTgeoType(type_ MeosType) bool { +func EnsureTgeoType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.ensure_tgeo_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TgeoTypeAll wraps MEOS C function tgeo_type_all. -func TgeoTypeAll(type_ MeosType) bool { +func TgeoTypeAll(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tgeo_type_all(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // EnsureTgeoTypeAll wraps MEOS C function ensure_tgeo_type_all. -func EnsureTgeoTypeAll(type_ MeosType) bool { +func EnsureTgeoTypeAll(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.ensure_tgeo_type_all(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TgeometryType wraps MEOS C function tgeometry_type. -func TgeometryType(type_ MeosType) bool { +func TgeometryType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tgeometry_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // EnsureTgeometryType wraps MEOS C function ensure_tgeometry_type. -func EnsureTgeometryType(type_ MeosType) bool { +func EnsureTgeometryType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.ensure_tgeometry_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TgeodeticType wraps MEOS C function tgeodetic_type. -func TgeodeticType(type_ MeosType) bool { +func TgeodeticType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tgeodetic_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // EnsureTgeodeticType wraps MEOS C function ensure_tgeodetic_type. -func EnsureTgeodeticType(type_ MeosType) bool { +func EnsureTgeodeticType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.ensure_tgeodetic_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // EnsureTnumberTpointType wraps MEOS C function ensure_tnumber_tpoint_type. -func EnsureTnumberTpointType(type_ MeosType) bool { +func EnsureTnumberTpointType(type_ MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.ensure_tnumber_tpoint_type(C.MeosType(type_)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } diff --git a/functions/meos_meos_cbuffer.go b/functions/meos_meos_cbuffer.go index e7fb340..44e5713 100644 --- a/functions/meos_meos_cbuffer.go +++ b/functions/meos_meos_cbuffer.go @@ -86,1346 +86,2106 @@ import ( var _ = unsafe.Pointer(nil) // CbufferAsEWKT wraps MEOS C function cbuffer_as_ewkt. -func CbufferAsEWKT(cb *Cbuffer, maxdd int) string { +func CbufferAsEWKT(cb *Cbuffer, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_as_ewkt(cb._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // CbufferAsHexwkb wraps MEOS C function cbuffer_as_hexwkb. -func CbufferAsHexwkb(cb *Cbuffer, variant uint8, size_out unsafe.Pointer) string { +func CbufferAsHexwkb(cb *Cbuffer, variant uint8, size_out unsafe.Pointer) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_as_hexwkb(cb._inner, C.uint8_t(variant), (*C.size_t)(unsafe.Pointer(size_out))) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // CbufferAsText wraps MEOS C function cbuffer_as_text. -func CbufferAsText(cb *Cbuffer, maxdd int) string { +func CbufferAsText(cb *Cbuffer, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_as_text(cb._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // CbufferAsWKB wraps MEOS C function cbuffer_as_wkb. -func CbufferAsWKB(cb *Cbuffer, variant uint8, size_out unsafe.Pointer) unsafe.Pointer { +func CbufferAsWKB(cb *Cbuffer, variant uint8, size_out unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_as_wkb(cb._inner, C.uint8_t(variant), (*C.size_t)(unsafe.Pointer(size_out))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // CbufferFromHexwkb wraps MEOS C function cbuffer_from_hexwkb. -func CbufferFromHexwkb(hexwkb string) *Cbuffer { +func CbufferFromHexwkb(hexwkb string) (_r0 *Cbuffer, _err error) { _c_hexwkb := C.CString(hexwkb) defer C.free(unsafe.Pointer(_c_hexwkb)) + C.meos_errno_reset() _cret := C.cbuffer_from_hexwkb(_c_hexwkb) - return &Cbuffer{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Cbuffer{_inner: _cret}, nil } // CbufferFromWKB wraps MEOS C function cbuffer_from_wkb. -func CbufferFromWKB(wkb unsafe.Pointer, size uint) *Cbuffer { +func CbufferFromWKB(wkb unsafe.Pointer, size uint) (_r0 *Cbuffer, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_from_wkb((*C.uint8_t)(unsafe.Pointer(wkb)), C.size_t(size)) - return &Cbuffer{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Cbuffer{_inner: _cret}, nil } // CbufferIn wraps MEOS C function cbuffer_in. -func CbufferIn(str string) *Cbuffer { +func CbufferIn(str string) (_r0 *Cbuffer, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.cbuffer_in(_c_str) - return &Cbuffer{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Cbuffer{_inner: _cret}, nil } // CbufferOut wraps MEOS C function cbuffer_out. -func CbufferOut(cb *Cbuffer, maxdd int) string { +func CbufferOut(cb *Cbuffer, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_out(cb._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // CbufferCopy wraps MEOS C function cbuffer_copy. -func CbufferCopy(cb *Cbuffer) *Cbuffer { +func CbufferCopy(cb *Cbuffer) (_r0 *Cbuffer, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_copy(cb._inner) - return &Cbuffer{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Cbuffer{_inner: _cret}, nil } // CbufferMake wraps MEOS C function cbuffer_make. -func CbufferMake(point *Geom, radius float64) *Cbuffer { +func CbufferMake(point *Geom, radius float64) (_r0 *Cbuffer, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_make(point._inner, C.double(radius)) - return &Cbuffer{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Cbuffer{_inner: _cret}, nil } // CbufferToGeom wraps MEOS C function cbuffer_to_geom. -func CbufferToGeom(cb *Cbuffer) *Geom { +func CbufferToGeom(cb *Cbuffer) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_to_geom(cb._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // CbufferToSTBOX wraps MEOS C function cbuffer_to_stbox. -func CbufferToSTBOX(cb *Cbuffer) *STBox { +func CbufferToSTBOX(cb *Cbuffer) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_to_stbox(cb._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // CbufferarrToGeom wraps MEOS C function cbufferarr_to_geom. -func CbufferarrToGeom(cbarr unsafe.Pointer, count int) *Geom { +func CbufferarrToGeom(cbarr unsafe.Pointer, count int) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.cbufferarr_to_geom((**C.Cbuffer)(unsafe.Pointer(cbarr)), C.int(count)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeomToCbuffer wraps MEOS C function geom_to_cbuffer. -func GeomToCbuffer(gs *Geom) *Cbuffer { +func GeomToCbuffer(gs *Geom) (_r0 *Cbuffer, _err error) { + C.meos_errno_reset() _cret := C.geom_to_cbuffer(gs._inner) - return &Cbuffer{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Cbuffer{_inner: _cret}, nil } // CbufferHash wraps MEOS C function cbuffer_hash. -func CbufferHash(cb *Cbuffer) uint32 { +func CbufferHash(cb *Cbuffer) (_r0 uint32, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_hash(cb._inner) - return uint32(_cret) + if _err = meosError(); _err != nil { + return + } + return uint32(_cret), nil } // CbufferHashExtended wraps MEOS C function cbuffer_hash_extended. -func CbufferHashExtended(cb *Cbuffer, seed uint64) uint64 { +func CbufferHashExtended(cb *Cbuffer, seed uint64) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_hash_extended(cb._inner, C.uint64_t(seed)) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // CbufferPoint wraps MEOS C function cbuffer_point. -func CbufferPoint(cb *Cbuffer) *Geom { +func CbufferPoint(cb *Cbuffer) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_point(cb._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // CbufferRadius wraps MEOS C function cbuffer_radius. -func CbufferRadius(cb *Cbuffer) float64 { +func CbufferRadius(cb *Cbuffer) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_radius(cb._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // CbufferRound wraps MEOS C function cbuffer_round. -func CbufferRound(cb *Cbuffer, maxdd int) *Cbuffer { +func CbufferRound(cb *Cbuffer, maxdd int) (_r0 *Cbuffer, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_round(cb._inner, C.int(maxdd)) - return &Cbuffer{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Cbuffer{_inner: _cret}, nil } // CbufferarrRound wraps MEOS C function cbufferarr_round. -func CbufferarrRound(cbarr unsafe.Pointer, count int, maxdd int) unsafe.Pointer { +func CbufferarrRound(cbarr unsafe.Pointer, count int, maxdd int) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.cbufferarr_round((**C.Cbuffer)(unsafe.Pointer(cbarr)), C.int(count), C.int(maxdd)) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // CbufferSetSRID wraps MEOS C function cbuffer_set_srid. -func CbufferSetSRID(cb *Cbuffer, srid int32) *Cbuffer { +func CbufferSetSRID(cb *Cbuffer, srid int32) (_r0 *Cbuffer, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_set_srid(cb._inner, C.int32_t(srid)) - return &Cbuffer{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Cbuffer{_inner: _cret}, nil } // CbufferSRID wraps MEOS C function cbuffer_srid. -func CbufferSRID(cb *Cbuffer) int32 { +func CbufferSRID(cb *Cbuffer) (_r0 int32, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_srid(cb._inner) - return int32(_cret) + if _err = meosError(); _err != nil { + return + } + return int32(_cret), nil } // CbufferTransform wraps MEOS C function cbuffer_transform. -func CbufferTransform(cb *Cbuffer, srid int32) *Cbuffer { +func CbufferTransform(cb *Cbuffer, srid int32) (_r0 *Cbuffer, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_transform(cb._inner, C.int32_t(srid)) - return &Cbuffer{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Cbuffer{_inner: _cret}, nil } // CbufferTransformPipeline wraps MEOS C function cbuffer_transform_pipeline. -func CbufferTransformPipeline(cb *Cbuffer, pipelinestr string, srid int32, is_forward bool) *Cbuffer { +func CbufferTransformPipeline(cb *Cbuffer, pipelinestr string, srid int32, is_forward bool) (_r0 *Cbuffer, _err error) { _c_pipelinestr := C.CString(pipelinestr) defer C.free(unsafe.Pointer(_c_pipelinestr)) + C.meos_errno_reset() _cret := C.cbuffer_transform_pipeline(cb._inner, _c_pipelinestr, C.int32_t(srid), C.bool(is_forward)) - return &Cbuffer{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Cbuffer{_inner: _cret}, nil } // ContainsCbufferCbuffer wraps MEOS C function contains_cbuffer_cbuffer. -func ContainsCbufferCbuffer(cb1 *Cbuffer, cb2 *Cbuffer) int { +func ContainsCbufferCbuffer(cb1 *Cbuffer, cb2 *Cbuffer) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.contains_cbuffer_cbuffer(cb1._inner, cb2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // CoversCbufferCbuffer wraps MEOS C function covers_cbuffer_cbuffer. -func CoversCbufferCbuffer(cb1 *Cbuffer, cb2 *Cbuffer) int { +func CoversCbufferCbuffer(cb1 *Cbuffer, cb2 *Cbuffer) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.covers_cbuffer_cbuffer(cb1._inner, cb2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // DisjointCbufferCbuffer wraps MEOS C function disjoint_cbuffer_cbuffer. -func DisjointCbufferCbuffer(cb1 *Cbuffer, cb2 *Cbuffer) int { +func DisjointCbufferCbuffer(cb1 *Cbuffer, cb2 *Cbuffer) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.disjoint_cbuffer_cbuffer(cb1._inner, cb2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // DwithinCbufferCbuffer wraps MEOS C function dwithin_cbuffer_cbuffer. -func DwithinCbufferCbuffer(cb1 *Cbuffer, cb2 *Cbuffer, dist float64) int { +func DwithinCbufferCbuffer(cb1 *Cbuffer, cb2 *Cbuffer, dist float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.dwithin_cbuffer_cbuffer(cb1._inner, cb2._inner, C.double(dist)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // IntersectsCbufferCbuffer wraps MEOS C function intersects_cbuffer_cbuffer. -func IntersectsCbufferCbuffer(cb1 *Cbuffer, cb2 *Cbuffer) int { +func IntersectsCbufferCbuffer(cb1 *Cbuffer, cb2 *Cbuffer) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.intersects_cbuffer_cbuffer(cb1._inner, cb2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TouchesCbufferCbuffer wraps MEOS C function touches_cbuffer_cbuffer. -func TouchesCbufferCbuffer(cb1 *Cbuffer, cb2 *Cbuffer) int { +func TouchesCbufferCbuffer(cb1 *Cbuffer, cb2 *Cbuffer) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.touches_cbuffer_cbuffer(cb1._inner, cb2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // CbufferTstzspanToSTBOX wraps MEOS C function cbuffer_tstzspan_to_stbox. -func CbufferTstzspanToSTBOX(cb *Cbuffer, s *Span) *STBox { +func CbufferTstzspanToSTBOX(cb *Cbuffer, s *Span) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_tstzspan_to_stbox(cb._inner, s._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // CbufferTimestamptzToSTBOX wraps MEOS C function cbuffer_timestamptz_to_stbox. -func CbufferTimestamptzToSTBOX(cb *Cbuffer, t int64) *STBox { +func CbufferTimestamptzToSTBOX(cb *Cbuffer, t int64) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_timestamptz_to_stbox(cb._inner, C.TimestampTz(t)) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // DistanceCbufferCbuffer wraps MEOS C function distance_cbuffer_cbuffer. -func DistanceCbufferCbuffer(cb1 *Cbuffer, cb2 *Cbuffer) float64 { +func DistanceCbufferCbuffer(cb1 *Cbuffer, cb2 *Cbuffer) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.distance_cbuffer_cbuffer(cb1._inner, cb2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // DistanceCbufferGeo wraps MEOS C function distance_cbuffer_geo. -func DistanceCbufferGeo(cb *Cbuffer, gs *Geom) float64 { +func DistanceCbufferGeo(cb *Cbuffer, gs *Geom) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.distance_cbuffer_geo(cb._inner, gs._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // DistanceCbufferSTBOX wraps MEOS C function distance_cbuffer_stbox. -func DistanceCbufferSTBOX(cb *Cbuffer, box *STBox) float64 { +func DistanceCbufferSTBOX(cb *Cbuffer, box *STBox) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.distance_cbuffer_stbox(cb._inner, box._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NadCbufferSTBOX wraps MEOS C function nad_cbuffer_stbox. -func NadCbufferSTBOX(cb *Cbuffer, box *STBox) float64 { +func NadCbufferSTBOX(cb *Cbuffer, box *STBox) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_cbuffer_stbox(cb._inner, box._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // CbufferCmp wraps MEOS C function cbuffer_cmp. -func CbufferCmp(cb1 *Cbuffer, cb2 *Cbuffer) int { +func CbufferCmp(cb1 *Cbuffer, cb2 *Cbuffer) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_cmp(cb1._inner, cb2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // CbufferEq wraps MEOS C function cbuffer_eq. -func CbufferEq(cb1 *Cbuffer, cb2 *Cbuffer) bool { +func CbufferEq(cb1 *Cbuffer, cb2 *Cbuffer) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_eq(cb1._inner, cb2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // CbufferGe wraps MEOS C function cbuffer_ge. -func CbufferGe(cb1 *Cbuffer, cb2 *Cbuffer) bool { +func CbufferGe(cb1 *Cbuffer, cb2 *Cbuffer) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_ge(cb1._inner, cb2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // CbufferGt wraps MEOS C function cbuffer_gt. -func CbufferGt(cb1 *Cbuffer, cb2 *Cbuffer) bool { +func CbufferGt(cb1 *Cbuffer, cb2 *Cbuffer) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_gt(cb1._inner, cb2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // CbufferLe wraps MEOS C function cbuffer_le. -func CbufferLe(cb1 *Cbuffer, cb2 *Cbuffer) bool { +func CbufferLe(cb1 *Cbuffer, cb2 *Cbuffer) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_le(cb1._inner, cb2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // CbufferLt wraps MEOS C function cbuffer_lt. -func CbufferLt(cb1 *Cbuffer, cb2 *Cbuffer) bool { +func CbufferLt(cb1 *Cbuffer, cb2 *Cbuffer) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_lt(cb1._inner, cb2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // CbufferNe wraps MEOS C function cbuffer_ne. -func CbufferNe(cb1 *Cbuffer, cb2 *Cbuffer) bool { +func CbufferNe(cb1 *Cbuffer, cb2 *Cbuffer) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_ne(cb1._inner, cb2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // CbufferNsame wraps MEOS C function cbuffer_nsame. -func CbufferNsame(cb1 *Cbuffer, cb2 *Cbuffer) bool { +func CbufferNsame(cb1 *Cbuffer, cb2 *Cbuffer) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_nsame(cb1._inner, cb2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // CbufferSame wraps MEOS C function cbuffer_same. -func CbufferSame(cb1 *Cbuffer, cb2 *Cbuffer) bool { +func CbufferSame(cb1 *Cbuffer, cb2 *Cbuffer) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_same(cb1._inner, cb2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // CbuffersetIn wraps MEOS C function cbufferset_in. -func CbuffersetIn(str string) *Set { +func CbuffersetIn(str string) (_r0 *Set, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.cbufferset_in(_c_str) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // CbuffersetOut wraps MEOS C function cbufferset_out. -func CbuffersetOut(s *Set, maxdd int) string { +func CbuffersetOut(s *Set, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.cbufferset_out(s._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // CbuffersetMake wraps MEOS C function cbufferset_make. -func CbuffersetMake(values unsafe.Pointer, count int) *Set { +func CbuffersetMake(values unsafe.Pointer, count int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.cbufferset_make((**C.Cbuffer)(unsafe.Pointer(values)), C.int(count)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // CbufferToSet wraps MEOS C function cbuffer_to_set. -func CbufferToSet(cb *Cbuffer) *Set { +func CbufferToSet(cb *Cbuffer) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_to_set(cb._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // CbuffersetEndValue wraps MEOS C function cbufferset_end_value. -func CbuffersetEndValue(s *Set) *Cbuffer { +func CbuffersetEndValue(s *Set) (_r0 *Cbuffer, _err error) { + C.meos_errno_reset() _cret := C.cbufferset_end_value(s._inner) - return &Cbuffer{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Cbuffer{_inner: _cret}, nil } // CbuffersetStartValue wraps MEOS C function cbufferset_start_value. -func CbuffersetStartValue(s *Set) *Cbuffer { +func CbuffersetStartValue(s *Set) (_r0 *Cbuffer, _err error) { + C.meos_errno_reset() _cret := C.cbufferset_start_value(s._inner) - return &Cbuffer{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Cbuffer{_inner: _cret}, nil } // CbuffersetValueN wraps MEOS C function cbufferset_value_n. -func CbuffersetValueN(s *Set, n int) (bool, *Cbuffer) { +func CbuffersetValueN(s *Set, n int) (_r0 bool, _r1 *Cbuffer, _err error) { var _out_result *C.Cbuffer + C.meos_errno_reset() _cret := C.cbufferset_value_n(s._inner, C.int(n), &_out_result) - return bool(_cret), &Cbuffer{_inner: _out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Cbuffer{_inner: _out_result}, nil } // CbuffersetValues wraps MEOS C function cbufferset_values. -func CbuffersetValues(s *Set, count unsafe.Pointer) unsafe.Pointer { +func CbuffersetValues(s *Set, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.cbufferset_values(s._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // CbufferUnionTransfn wraps MEOS C function cbuffer_union_transfn. -func CbufferUnionTransfn(state *Set, cb *Cbuffer) *Set { +func CbufferUnionTransfn(state *Set, cb *Cbuffer) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.cbuffer_union_transfn(state._inner, cb._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // ContainedCbufferSet wraps MEOS C function contained_cbuffer_set. -func ContainedCbufferSet(cb *Cbuffer, s *Set) bool { +func ContainedCbufferSet(cb *Cbuffer, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_cbuffer_set(cb._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSetCbuffer wraps MEOS C function contains_set_cbuffer. -func ContainsSetCbuffer(s *Set, cb *Cbuffer) bool { +func ContainsSetCbuffer(s *Set, cb *Cbuffer) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_set_cbuffer(s._inner, cb._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // IntersectionCbufferSet wraps MEOS C function intersection_cbuffer_set. -func IntersectionCbufferSet(cb *Cbuffer, s *Set) *Set { +func IntersectionCbufferSet(cb *Cbuffer, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_cbuffer_set(cb._inner, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntersectionSetCbuffer wraps MEOS C function intersection_set_cbuffer. -func IntersectionSetCbuffer(s *Set, cb *Cbuffer) *Set { +func IntersectionSetCbuffer(s *Set, cb *Cbuffer) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_set_cbuffer(s._inner, cb._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusCbufferSet wraps MEOS C function minus_cbuffer_set. -func MinusCbufferSet(cb *Cbuffer, s *Set) *Set { +func MinusCbufferSet(cb *Cbuffer, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_cbuffer_set(cb._inner, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusSetCbuffer wraps MEOS C function minus_set_cbuffer. -func MinusSetCbuffer(s *Set, cb *Cbuffer) *Set { +func MinusSetCbuffer(s *Set, cb *Cbuffer) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_set_cbuffer(s._inner, cb._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionCbufferSet wraps MEOS C function union_cbuffer_set. -func UnionCbufferSet(cb *Cbuffer, s *Set) *Set { +func UnionCbufferSet(cb *Cbuffer, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_cbuffer_set(cb._inner, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionSetCbuffer wraps MEOS C function union_set_cbuffer. -func UnionSetCbuffer(s *Set, cb *Cbuffer) *Set { +func UnionSetCbuffer(s *Set, cb *Cbuffer) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_set_cbuffer(s._inner, cb._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TcbufferIn wraps MEOS C function tcbuffer_in. -func TcbufferIn(str string) *Temporal { +func TcbufferIn(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tcbuffer_in(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcbufferFromMFJSON wraps MEOS C function tcbuffer_from_mfjson. -func TcbufferFromMFJSON(mfjson string) *Temporal { +func TcbufferFromMFJSON(mfjson string) (_r0 *Temporal, _err error) { _c_mfjson := C.CString(mfjson) defer C.free(unsafe.Pointer(_c_mfjson)) + C.meos_errno_reset() _cret := C.tcbuffer_from_mfjson(_c_mfjson) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcbufferinstMake wraps MEOS C function tcbufferinst_make. -func TcbufferinstMake(cb *Cbuffer, t int64) *TInstant { +func TcbufferinstMake(cb *Cbuffer, t int64) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tcbufferinst_make(cb._inner, C.TimestampTz(t)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TcbufferMake wraps MEOS C function tcbuffer_make. -func TcbufferMake(tpoint *Temporal, tfloat *Temporal) *Temporal { +func TcbufferMake(tpoint *Temporal, tfloat *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcbuffer_make(tpoint._inner, tfloat._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcbufferFromBaseTemp wraps MEOS C function tcbuffer_from_base_temp. -func TcbufferFromBaseTemp(cb *Cbuffer, temp *Temporal) *Temporal { +func TcbufferFromBaseTemp(cb *Cbuffer, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcbuffer_from_base_temp(cb._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcbufferseqFromBaseTstzset wraps MEOS C function tcbufferseq_from_base_tstzset. -func TcbufferseqFromBaseTstzset(cb *Cbuffer, s *Set) *TSequence { +func TcbufferseqFromBaseTstzset(cb *Cbuffer, s *Set) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tcbufferseq_from_base_tstzset(cb._inner, s._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TcbufferseqFromBaseTstzspan wraps MEOS C function tcbufferseq_from_base_tstzspan. -func TcbufferseqFromBaseTstzspan(cb *Cbuffer, s *Span, interp Interpolation) *TSequence { +func TcbufferseqFromBaseTstzspan(cb *Cbuffer, s *Span, interp Interpolation) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tcbufferseq_from_base_tstzspan(cb._inner, s._inner, C.interpType(interp)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TcbufferseqsetFromBaseTstzspanset wraps MEOS C function tcbufferseqset_from_base_tstzspanset. -func TcbufferseqsetFromBaseTstzspanset(cb *Cbuffer, ss *SpanSet, interp Interpolation) *TSequenceSet { +func TcbufferseqsetFromBaseTstzspanset(cb *Cbuffer, ss *SpanSet, interp Interpolation) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tcbufferseqset_from_base_tstzspanset(cb._inner, ss._inner, C.interpType(interp)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TcbufferEndValue wraps MEOS C function tcbuffer_end_value. -func TcbufferEndValue(temp *Temporal) *Cbuffer { +func TcbufferEndValue(temp *Temporal) (_r0 *Cbuffer, _err error) { + C.meos_errno_reset() _cret := C.tcbuffer_end_value(temp._inner) - return &Cbuffer{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Cbuffer{_inner: _cret}, nil } // TcbufferPoints wraps MEOS C function tcbuffer_points. -func TcbufferPoints(temp *Temporal) *Set { +func TcbufferPoints(temp *Temporal) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.tcbuffer_points(temp._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TcbufferRadius wraps MEOS C function tcbuffer_radius. -func TcbufferRadius(temp *Temporal) *Set { +func TcbufferRadius(temp *Temporal) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.tcbuffer_radius(temp._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TcbufferTraversedArea wraps MEOS C function tcbuffer_traversed_area. -func TcbufferTraversedArea(temp *Temporal, unary_union bool) *Geom { +func TcbufferTraversedArea(temp *Temporal, unary_union bool) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.tcbuffer_traversed_area(temp._inner, C.bool(unary_union)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // TcbufferConvexHull wraps MEOS C function tcbuffer_convex_hull. -func TcbufferConvexHull(temp *Temporal) *Geom { +func TcbufferConvexHull(temp *Temporal) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.tcbuffer_convex_hull(temp._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // TcbufferStartValue wraps MEOS C function tcbuffer_start_value. -func TcbufferStartValue(temp *Temporal) *Cbuffer { +func TcbufferStartValue(temp *Temporal) (_r0 *Cbuffer, _err error) { + C.meos_errno_reset() _cret := C.tcbuffer_start_value(temp._inner) - return &Cbuffer{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Cbuffer{_inner: _cret}, nil } // TcbufferValueAtTimestamptz wraps MEOS C function tcbuffer_value_at_timestamptz. -func TcbufferValueAtTimestamptz(temp *Temporal, t int64, strict bool) (bool, *Cbuffer) { +func TcbufferValueAtTimestamptz(temp *Temporal, t int64, strict bool) (_r0 bool, _r1 *Cbuffer, _err error) { var _out_value *C.Cbuffer + C.meos_errno_reset() _cret := C.tcbuffer_value_at_timestamptz(temp._inner, C.TimestampTz(t), C.bool(strict), &_out_value) - return bool(_cret), &Cbuffer{_inner: _out_value} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Cbuffer{_inner: _out_value}, nil } // TcbufferValueN wraps MEOS C function tcbuffer_value_n. -func TcbufferValueN(temp *Temporal, n int) (bool, *Cbuffer) { +func TcbufferValueN(temp *Temporal, n int) (_r0 bool, _r1 *Cbuffer, _err error) { var _out_result *C.Cbuffer + C.meos_errno_reset() _cret := C.tcbuffer_value_n(temp._inner, C.int(n), &_out_result) - return bool(_cret), &Cbuffer{_inner: _out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Cbuffer{_inner: _out_result}, nil } // TcbufferValues wraps MEOS C function tcbuffer_values. -func TcbufferValues(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TcbufferValues(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tcbuffer_values(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TcbufferToTfloat wraps MEOS C function tcbuffer_to_tfloat. -func TcbufferToTfloat(temp *Temporal) *Temporal { +func TcbufferToTfloat(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcbuffer_to_tfloat(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcbufferToTgeompoint wraps MEOS C function tcbuffer_to_tgeompoint. -func TcbufferToTgeompoint(temp *Temporal) *Temporal { +func TcbufferToTgeompoint(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcbuffer_to_tgeompoint(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeometryToTcbuffer wraps MEOS C function tgeometry_to_tcbuffer. -func TgeometryToTcbuffer(temp *Temporal) *Temporal { +func TgeometryToTcbuffer(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeometry_to_tcbuffer(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcbufferExpand wraps MEOS C function tcbuffer_expand. -func TcbufferExpand(temp *Temporal, dist float64) *Temporal { +func TcbufferExpand(temp *Temporal, dist float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcbuffer_expand(temp._inner, C.double(dist)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcbufferAtCbuffer wraps MEOS C function tcbuffer_at_cbuffer. -func TcbufferAtCbuffer(temp *Temporal, cb *Cbuffer) *Temporal { +func TcbufferAtCbuffer(temp *Temporal, cb *Cbuffer) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcbuffer_at_cbuffer(temp._inner, cb._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcbufferAtGeom wraps MEOS C function tcbuffer_at_geom. -func TcbufferAtGeom(temp *Temporal, gs *Geom) *Temporal { +func TcbufferAtGeom(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcbuffer_at_geom(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcbufferAtSTBOX wraps MEOS C function tcbuffer_at_stbox. -func TcbufferAtSTBOX(temp *Temporal, box *STBox, border_inc bool) *Temporal { +func TcbufferAtSTBOX(temp *Temporal, box *STBox, border_inc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcbuffer_at_stbox(temp._inner, box._inner, C.bool(border_inc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcbufferMinusCbuffer wraps MEOS C function tcbuffer_minus_cbuffer. -func TcbufferMinusCbuffer(temp *Temporal, cb *Cbuffer) *Temporal { +func TcbufferMinusCbuffer(temp *Temporal, cb *Cbuffer) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcbuffer_minus_cbuffer(temp._inner, cb._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcbufferMinusGeom wraps MEOS C function tcbuffer_minus_geom. -func TcbufferMinusGeom(temp *Temporal, gs *Geom) *Temporal { +func TcbufferMinusGeom(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcbuffer_minus_geom(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcbufferMinusSTBOX wraps MEOS C function tcbuffer_minus_stbox. -func TcbufferMinusSTBOX(temp *Temporal, box *STBox, border_inc bool) *Temporal { +func TcbufferMinusSTBOX(temp *Temporal, box *STBox, border_inc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcbuffer_minus_stbox(temp._inner, box._inner, C.bool(border_inc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdistanceTcbufferCbuffer wraps MEOS C function tdistance_tcbuffer_cbuffer. -func TdistanceTcbufferCbuffer(temp *Temporal, cb *Cbuffer) *Temporal { +func TdistanceTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdistance_tcbuffer_cbuffer(temp._inner, cb._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdistanceTcbufferGeo wraps MEOS C function tdistance_tcbuffer_geo. -func TdistanceTcbufferGeo(temp *Temporal, gs *Geom) *Temporal { +func TdistanceTcbufferGeo(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdistance_tcbuffer_geo(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdistanceTcbufferTcbuffer wraps MEOS C function tdistance_tcbuffer_tcbuffer. -func TdistanceTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TdistanceTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdistance_tcbuffer_tcbuffer(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // NadTcbufferCbuffer wraps MEOS C function nad_tcbuffer_cbuffer. -func NadTcbufferCbuffer(temp *Temporal, cb *Cbuffer) float64 { +func NadTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_tcbuffer_cbuffer(temp._inner, cb._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NadTcbufferGeo wraps MEOS C function nad_tcbuffer_geo. -func NadTcbufferGeo(temp *Temporal, gs *Geom) float64 { +func NadTcbufferGeo(temp *Temporal, gs *Geom) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_tcbuffer_geo(temp._inner, gs._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NadTcbufferSTBOX wraps MEOS C function nad_tcbuffer_stbox. -func NadTcbufferSTBOX(temp *Temporal, box *STBox) float64 { +func NadTcbufferSTBOX(temp *Temporal, box *STBox) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_tcbuffer_stbox(temp._inner, box._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NadTcbufferTcbuffer wraps MEOS C function nad_tcbuffer_tcbuffer. -func NadTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) float64 { +func NadTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_tcbuffer_tcbuffer(temp1._inner, temp2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // MindistanceTcbufferTcbuffer wraps MEOS C function mindistance_tcbuffer_tcbuffer. -func MindistanceTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal, threshold float64) float64 { +func MindistanceTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal, threshold float64) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.mindistance_tcbuffer_tcbuffer(temp1._inner, temp2._inner, C.double(threshold)) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NaiTcbufferCbuffer wraps MEOS C function nai_tcbuffer_cbuffer. -func NaiTcbufferCbuffer(temp *Temporal, cb *Cbuffer) *TInstant { +func NaiTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.nai_tcbuffer_cbuffer(temp._inner, cb._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // NaiTcbufferGeo wraps MEOS C function nai_tcbuffer_geo. -func NaiTcbufferGeo(temp *Temporal, gs *Geom) *TInstant { +func NaiTcbufferGeo(temp *Temporal, gs *Geom) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.nai_tcbuffer_geo(temp._inner, gs._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // NaiTcbufferTcbuffer wraps MEOS C function nai_tcbuffer_tcbuffer. -func NaiTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) *TInstant { +func NaiTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.nai_tcbuffer_tcbuffer(temp1._inner, temp2._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // ShortestlineTcbufferCbuffer wraps MEOS C function shortestline_tcbuffer_cbuffer. -func ShortestlineTcbufferCbuffer(temp *Temporal, cb *Cbuffer) *Geom { +func ShortestlineTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.shortestline_tcbuffer_cbuffer(temp._inner, cb._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // ShortestlineTcbufferGeo wraps MEOS C function shortestline_tcbuffer_geo. -func ShortestlineTcbufferGeo(temp *Temporal, gs *Geom) *Geom { +func ShortestlineTcbufferGeo(temp *Temporal, gs *Geom) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.shortestline_tcbuffer_geo(temp._inner, gs._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // ShortestlineTcbufferTcbuffer wraps MEOS C function shortestline_tcbuffer_tcbuffer. -func ShortestlineTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) *Geom { +func ShortestlineTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.shortestline_tcbuffer_tcbuffer(temp1._inner, temp2._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // AlwaysEqCbufferTcbuffer wraps MEOS C function always_eq_cbuffer_tcbuffer. -func AlwaysEqCbufferTcbuffer(cb *Cbuffer, temp *Temporal) int { +func AlwaysEqCbufferTcbuffer(cb *Cbuffer, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_cbuffer_tcbuffer(cb._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTcbufferCbuffer wraps MEOS C function always_eq_tcbuffer_cbuffer. -func AlwaysEqTcbufferCbuffer(temp *Temporal, cb *Cbuffer) int { +func AlwaysEqTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_tcbuffer_cbuffer(temp._inner, cb._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTcbufferTcbuffer wraps MEOS C function always_eq_tcbuffer_tcbuffer. -func AlwaysEqTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysEqTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_tcbuffer_tcbuffer(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeCbufferTcbuffer wraps MEOS C function always_ne_cbuffer_tcbuffer. -func AlwaysNeCbufferTcbuffer(cb *Cbuffer, temp *Temporal) int { +func AlwaysNeCbufferTcbuffer(cb *Cbuffer, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_cbuffer_tcbuffer(cb._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTcbufferCbuffer wraps MEOS C function always_ne_tcbuffer_cbuffer. -func AlwaysNeTcbufferCbuffer(temp *Temporal, cb *Cbuffer) int { +func AlwaysNeTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_tcbuffer_cbuffer(temp._inner, cb._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTcbufferTcbuffer wraps MEOS C function always_ne_tcbuffer_tcbuffer. -func AlwaysNeTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysNeTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_tcbuffer_tcbuffer(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqCbufferTcbuffer wraps MEOS C function ever_eq_cbuffer_tcbuffer. -func EverEqCbufferTcbuffer(cb *Cbuffer, temp *Temporal) int { +func EverEqCbufferTcbuffer(cb *Cbuffer, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_cbuffer_tcbuffer(cb._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTcbufferCbuffer wraps MEOS C function ever_eq_tcbuffer_cbuffer. -func EverEqTcbufferCbuffer(temp *Temporal, cb *Cbuffer) int { +func EverEqTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_tcbuffer_cbuffer(temp._inner, cb._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTcbufferTcbuffer wraps MEOS C function ever_eq_tcbuffer_tcbuffer. -func EverEqTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) int { +func EverEqTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_tcbuffer_tcbuffer(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeCbufferTcbuffer wraps MEOS C function ever_ne_cbuffer_tcbuffer. -func EverNeCbufferTcbuffer(cb *Cbuffer, temp *Temporal) int { +func EverNeCbufferTcbuffer(cb *Cbuffer, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_cbuffer_tcbuffer(cb._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTcbufferCbuffer wraps MEOS C function ever_ne_tcbuffer_cbuffer. -func EverNeTcbufferCbuffer(temp *Temporal, cb *Cbuffer) int { +func EverNeTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_tcbuffer_cbuffer(temp._inner, cb._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTcbufferTcbuffer wraps MEOS C function ever_ne_tcbuffer_tcbuffer. -func EverNeTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) int { +func EverNeTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_tcbuffer_tcbuffer(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TeqCbufferTcbuffer wraps MEOS C function teq_cbuffer_tcbuffer. -func TeqCbufferTcbuffer(cb *Cbuffer, temp *Temporal) *Temporal { +func TeqCbufferTcbuffer(cb *Cbuffer, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_cbuffer_tcbuffer(cb._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TeqTcbufferCbuffer wraps MEOS C function teq_tcbuffer_cbuffer. -func TeqTcbufferCbuffer(temp *Temporal, cb *Cbuffer) *Temporal { +func TeqTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_tcbuffer_cbuffer(temp._inner, cb._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneCbufferTcbuffer wraps MEOS C function tne_cbuffer_tcbuffer. -func TneCbufferTcbuffer(cb *Cbuffer, temp *Temporal) *Temporal { +func TneCbufferTcbuffer(cb *Cbuffer, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_cbuffer_tcbuffer(cb._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneTcbufferCbuffer wraps MEOS C function tne_tcbuffer_cbuffer. -func TneTcbufferCbuffer(temp *Temporal, cb *Cbuffer) *Temporal { +func TneTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_tcbuffer_cbuffer(temp._inner, cb._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // AcontainsCbufferTcbuffer wraps MEOS C function acontains_cbuffer_tcbuffer. -func AcontainsCbufferTcbuffer(cb *Cbuffer, temp *Temporal) int { +func AcontainsCbufferTcbuffer(cb *Cbuffer, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.acontains_cbuffer_tcbuffer(cb._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AcontainsGeoTcbuffer wraps MEOS C function acontains_geo_tcbuffer. -func AcontainsGeoTcbuffer(gs *Geom, temp *Temporal) int { +func AcontainsGeoTcbuffer(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.acontains_geo_tcbuffer(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AcontainsTcbufferCbuffer wraps MEOS C function acontains_tcbuffer_cbuffer. -func AcontainsTcbufferCbuffer(temp *Temporal, cb *Cbuffer) int { +func AcontainsTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.acontains_tcbuffer_cbuffer(temp._inner, cb._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AcontainsTcbufferGeo wraps MEOS C function acontains_tcbuffer_geo. -func AcontainsTcbufferGeo(temp *Temporal, gs *Geom) int { +func AcontainsTcbufferGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.acontains_tcbuffer_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AcontainsTcbufferTcbuffer wraps MEOS C function acontains_tcbuffer_tcbuffer. -func AcontainsTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) int { +func AcontainsTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.acontains_tcbuffer_tcbuffer(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AcoversCbufferTcbuffer wraps MEOS C function acovers_cbuffer_tcbuffer. -func AcoversCbufferTcbuffer(cb *Cbuffer, temp *Temporal) int { +func AcoversCbufferTcbuffer(cb *Cbuffer, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.acovers_cbuffer_tcbuffer(cb._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AcoversGeoTcbuffer wraps MEOS C function acovers_geo_tcbuffer. -func AcoversGeoTcbuffer(gs *Geom, temp *Temporal) int { +func AcoversGeoTcbuffer(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.acovers_geo_tcbuffer(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AcoversTcbufferCbuffer wraps MEOS C function acovers_tcbuffer_cbuffer. -func AcoversTcbufferCbuffer(temp *Temporal, cb *Cbuffer) int { +func AcoversTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.acovers_tcbuffer_cbuffer(temp._inner, cb._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AcoversTcbufferGeo wraps MEOS C function acovers_tcbuffer_geo. -func AcoversTcbufferGeo(temp *Temporal, gs *Geom) int { +func AcoversTcbufferGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.acovers_tcbuffer_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AcoversTcbufferTcbuffer wraps MEOS C function acovers_tcbuffer_tcbuffer. -func AcoversTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) int { +func AcoversTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.acovers_tcbuffer_tcbuffer(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AdisjointTcbufferGeo wraps MEOS C function adisjoint_tcbuffer_geo. -func AdisjointTcbufferGeo(temp *Temporal, gs *Geom) int { +func AdisjointTcbufferGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.adisjoint_tcbuffer_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AdisjointTcbufferCbuffer wraps MEOS C function adisjoint_tcbuffer_cbuffer. -func AdisjointTcbufferCbuffer(temp *Temporal, cb *Cbuffer) int { +func AdisjointTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.adisjoint_tcbuffer_cbuffer(temp._inner, cb._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AdisjointTcbufferTcbuffer wraps MEOS C function adisjoint_tcbuffer_tcbuffer. -func AdisjointTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) int { +func AdisjointTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.adisjoint_tcbuffer_tcbuffer(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AdwithinTcbufferGeo wraps MEOS C function adwithin_tcbuffer_geo. -func AdwithinTcbufferGeo(temp *Temporal, gs *Geom, dist float64) int { +func AdwithinTcbufferGeo(temp *Temporal, gs *Geom, dist float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.adwithin_tcbuffer_geo(temp._inner, gs._inner, C.double(dist)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AdwithinTcbufferCbuffer wraps MEOS C function adwithin_tcbuffer_cbuffer. -func AdwithinTcbufferCbuffer(temp *Temporal, cb *Cbuffer, dist float64) int { +func AdwithinTcbufferCbuffer(temp *Temporal, cb *Cbuffer, dist float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.adwithin_tcbuffer_cbuffer(temp._inner, cb._inner, C.double(dist)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AdwithinTcbufferTcbuffer wraps MEOS C function adwithin_tcbuffer_tcbuffer. -func AdwithinTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal, dist float64) int { +func AdwithinTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal, dist float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.adwithin_tcbuffer_tcbuffer(temp1._inner, temp2._inner, C.double(dist)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AintersectsTcbufferGeo wraps MEOS C function aintersects_tcbuffer_geo. -func AintersectsTcbufferGeo(temp *Temporal, gs *Geom) int { +func AintersectsTcbufferGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.aintersects_tcbuffer_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AintersectsTcbufferCbuffer wraps MEOS C function aintersects_tcbuffer_cbuffer. -func AintersectsTcbufferCbuffer(temp *Temporal, cb *Cbuffer) int { +func AintersectsTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.aintersects_tcbuffer_cbuffer(temp._inner, cb._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AintersectsTcbufferTcbuffer wraps MEOS C function aintersects_tcbuffer_tcbuffer. -func AintersectsTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) int { +func AintersectsTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.aintersects_tcbuffer_tcbuffer(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AtouchesTcbufferGeo wraps MEOS C function atouches_tcbuffer_geo. -func AtouchesTcbufferGeo(temp *Temporal, gs *Geom) int { +func AtouchesTcbufferGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.atouches_tcbuffer_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AtouchesTcbufferCbuffer wraps MEOS C function atouches_tcbuffer_cbuffer. -func AtouchesTcbufferCbuffer(temp *Temporal, cb *Cbuffer) int { +func AtouchesTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.atouches_tcbuffer_cbuffer(temp._inner, cb._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AtouchesTcbufferTcbuffer wraps MEOS C function atouches_tcbuffer_tcbuffer. -func AtouchesTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) int { +func AtouchesTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.atouches_tcbuffer_tcbuffer(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EcontainsCbufferTcbuffer wraps MEOS C function econtains_cbuffer_tcbuffer. -func EcontainsCbufferTcbuffer(cb *Cbuffer, temp *Temporal) int { +func EcontainsCbufferTcbuffer(cb *Cbuffer, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.econtains_cbuffer_tcbuffer(cb._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EcontainsTcbufferCbuffer wraps MEOS C function econtains_tcbuffer_cbuffer. -func EcontainsTcbufferCbuffer(temp *Temporal, cb *Cbuffer) int { +func EcontainsTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.econtains_tcbuffer_cbuffer(temp._inner, cb._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EcontainsTcbufferGeo wraps MEOS C function econtains_tcbuffer_geo. -func EcontainsTcbufferGeo(temp *Temporal, gs *Geom) int { +func EcontainsTcbufferGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.econtains_tcbuffer_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EcontainsTcbufferTcbuffer wraps MEOS C function econtains_tcbuffer_tcbuffer. -func EcontainsTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) int { +func EcontainsTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.econtains_tcbuffer_tcbuffer(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EcoversCbufferTcbuffer wraps MEOS C function ecovers_cbuffer_tcbuffer. -func EcoversCbufferTcbuffer(cb *Cbuffer, temp *Temporal) int { +func EcoversCbufferTcbuffer(cb *Cbuffer, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ecovers_cbuffer_tcbuffer(cb._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EcoversGeoTcbuffer wraps MEOS C function ecovers_geo_tcbuffer. -func EcoversGeoTcbuffer(gs *Geom, temp *Temporal) int { +func EcoversGeoTcbuffer(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ecovers_geo_tcbuffer(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EcoversTcbufferCbuffer wraps MEOS C function ecovers_tcbuffer_cbuffer. -func EcoversTcbufferCbuffer(temp *Temporal, cb *Cbuffer) int { +func EcoversTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ecovers_tcbuffer_cbuffer(temp._inner, cb._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EcoversTcbufferGeo wraps MEOS C function ecovers_tcbuffer_geo. -func EcoversTcbufferGeo(temp *Temporal, gs *Geom) int { +func EcoversTcbufferGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ecovers_tcbuffer_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EcoversTcbufferTcbuffer wraps MEOS C function ecovers_tcbuffer_tcbuffer. -func EcoversTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) int { +func EcoversTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ecovers_tcbuffer_tcbuffer(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EdisjointTcbufferGeo wraps MEOS C function edisjoint_tcbuffer_geo. -func EdisjointTcbufferGeo(temp *Temporal, gs *Geom) int { +func EdisjointTcbufferGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.edisjoint_tcbuffer_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EdisjointTcbufferCbuffer wraps MEOS C function edisjoint_tcbuffer_cbuffer. -func EdisjointTcbufferCbuffer(temp *Temporal, cb *Cbuffer) int { +func EdisjointTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.edisjoint_tcbuffer_cbuffer(temp._inner, cb._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EdwithinTcbufferGeo wraps MEOS C function edwithin_tcbuffer_geo. -func EdwithinTcbufferGeo(temp *Temporal, gs *Geom, dist float64) int { +func EdwithinTcbufferGeo(temp *Temporal, gs *Geom, dist float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.edwithin_tcbuffer_geo(temp._inner, gs._inner, C.double(dist)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EdwithinTcbufferCbuffer wraps MEOS C function edwithin_tcbuffer_cbuffer. -func EdwithinTcbufferCbuffer(temp *Temporal, cb *Cbuffer, dist float64) int { +func EdwithinTcbufferCbuffer(temp *Temporal, cb *Cbuffer, dist float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.edwithin_tcbuffer_cbuffer(temp._inner, cb._inner, C.double(dist)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EdwithinTcbufferTcbuffer wraps MEOS C function edwithin_tcbuffer_tcbuffer. -func EdwithinTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal, dist float64) int { +func EdwithinTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal, dist float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.edwithin_tcbuffer_tcbuffer(temp1._inner, temp2._inner, C.double(dist)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EintersectsTcbufferGeo wraps MEOS C function eintersects_tcbuffer_geo. -func EintersectsTcbufferGeo(temp *Temporal, gs *Geom) int { +func EintersectsTcbufferGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.eintersects_tcbuffer_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EintersectsTcbufferCbuffer wraps MEOS C function eintersects_tcbuffer_cbuffer. -func EintersectsTcbufferCbuffer(temp *Temporal, cb *Cbuffer) int { +func EintersectsTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.eintersects_tcbuffer_cbuffer(temp._inner, cb._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EintersectsTcbufferTcbuffer wraps MEOS C function eintersects_tcbuffer_tcbuffer. -func EintersectsTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) int { +func EintersectsTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.eintersects_tcbuffer_tcbuffer(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EtouchesTcbufferGeo wraps MEOS C function etouches_tcbuffer_geo. -func EtouchesTcbufferGeo(temp *Temporal, gs *Geom) int { +func EtouchesTcbufferGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.etouches_tcbuffer_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EtouchesTcbufferCbuffer wraps MEOS C function etouches_tcbuffer_cbuffer. -func EtouchesTcbufferCbuffer(temp *Temporal, cb *Cbuffer) int { +func EtouchesTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.etouches_tcbuffer_cbuffer(temp._inner, cb._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EtouchesTcbufferTcbuffer wraps MEOS C function etouches_tcbuffer_tcbuffer. -func EtouchesTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) int { +func EtouchesTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.etouches_tcbuffer_tcbuffer(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TcontainsCbufferTcbuffer wraps MEOS C function tcontains_cbuffer_tcbuffer. -func TcontainsCbufferTcbuffer(cb *Cbuffer, temp *Temporal) *Temporal { +func TcontainsCbufferTcbuffer(cb *Cbuffer, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcontains_cbuffer_tcbuffer(cb._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcontainsGeoTcbuffer wraps MEOS C function tcontains_geo_tcbuffer. -func TcontainsGeoTcbuffer(gs *Geom, temp *Temporal) *Temporal { +func TcontainsGeoTcbuffer(gs *Geom, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcontains_geo_tcbuffer(gs._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcontainsTcbufferGeo wraps MEOS C function tcontains_tcbuffer_geo. -func TcontainsTcbufferGeo(temp *Temporal, gs *Geom) *Temporal { +func TcontainsTcbufferGeo(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcontains_tcbuffer_geo(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcontainsTcbufferCbuffer wraps MEOS C function tcontains_tcbuffer_cbuffer. -func TcontainsTcbufferCbuffer(temp *Temporal, cb *Cbuffer) *Temporal { +func TcontainsTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcontains_tcbuffer_cbuffer(temp._inner, cb._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcontainsTcbufferTcbuffer wraps MEOS C function tcontains_tcbuffer_tcbuffer. -func TcontainsTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TcontainsTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcontains_tcbuffer_tcbuffer(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcoversCbufferTcbuffer wraps MEOS C function tcovers_cbuffer_tcbuffer. -func TcoversCbufferTcbuffer(cb *Cbuffer, temp *Temporal) *Temporal { +func TcoversCbufferTcbuffer(cb *Cbuffer, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcovers_cbuffer_tcbuffer(cb._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcoversGeoTcbuffer wraps MEOS C function tcovers_geo_tcbuffer. -func TcoversGeoTcbuffer(gs *Geom, temp *Temporal) *Temporal { +func TcoversGeoTcbuffer(gs *Geom, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcovers_geo_tcbuffer(gs._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcoversTcbufferGeo wraps MEOS C function tcovers_tcbuffer_geo. -func TcoversTcbufferGeo(temp *Temporal, gs *Geom) *Temporal { +func TcoversTcbufferGeo(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcovers_tcbuffer_geo(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcoversTcbufferCbuffer wraps MEOS C function tcovers_tcbuffer_cbuffer. -func TcoversTcbufferCbuffer(temp *Temporal, cb *Cbuffer) *Temporal { +func TcoversTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcovers_tcbuffer_cbuffer(temp._inner, cb._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcoversTcbufferTcbuffer wraps MEOS C function tcovers_tcbuffer_tcbuffer. -func TcoversTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TcoversTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcovers_tcbuffer_tcbuffer(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdwithinGeoTcbuffer wraps MEOS C function tdwithin_geo_tcbuffer. -func TdwithinGeoTcbuffer(gs *Geom, temp *Temporal, dist float64) *Temporal { +func TdwithinGeoTcbuffer(gs *Geom, temp *Temporal, dist float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdwithin_geo_tcbuffer(gs._inner, temp._inner, C.double(dist)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdwithinTcbufferGeo wraps MEOS C function tdwithin_tcbuffer_geo. -func TdwithinTcbufferGeo(temp *Temporal, gs *Geom, dist float64) *Temporal { +func TdwithinTcbufferGeo(temp *Temporal, gs *Geom, dist float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdwithin_tcbuffer_geo(temp._inner, gs._inner, C.double(dist)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdwithinTcbufferCbuffer wraps MEOS C function tdwithin_tcbuffer_cbuffer. -func TdwithinTcbufferCbuffer(temp *Temporal, cb *Cbuffer, dist float64) *Temporal { +func TdwithinTcbufferCbuffer(temp *Temporal, cb *Cbuffer, dist float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdwithin_tcbuffer_cbuffer(temp._inner, cb._inner, C.double(dist)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdwithinTcbufferTcbuffer wraps MEOS C function tdwithin_tcbuffer_tcbuffer. -func TdwithinTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal, dist float64) *Temporal { +func TdwithinTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal, dist float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdwithin_tcbuffer_tcbuffer(temp1._inner, temp2._inner, C.double(dist)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdisjointCbufferTcbuffer wraps MEOS C function tdisjoint_cbuffer_tcbuffer. -func TdisjointCbufferTcbuffer(cb *Cbuffer, temp *Temporal) *Temporal { +func TdisjointCbufferTcbuffer(cb *Cbuffer, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdisjoint_cbuffer_tcbuffer(cb._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdisjointGeoTcbuffer wraps MEOS C function tdisjoint_geo_tcbuffer. -func TdisjointGeoTcbuffer(gs *Geom, temp *Temporal) *Temporal { +func TdisjointGeoTcbuffer(gs *Geom, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdisjoint_geo_tcbuffer(gs._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdisjointTcbufferGeo wraps MEOS C function tdisjoint_tcbuffer_geo. -func TdisjointTcbufferGeo(temp *Temporal, gs *Geom) *Temporal { +func TdisjointTcbufferGeo(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdisjoint_tcbuffer_geo(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdisjointTcbufferCbuffer wraps MEOS C function tdisjoint_tcbuffer_cbuffer. -func TdisjointTcbufferCbuffer(temp *Temporal, cb *Cbuffer) *Temporal { +func TdisjointTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdisjoint_tcbuffer_cbuffer(temp._inner, cb._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdisjointTcbufferTcbuffer wraps MEOS C function tdisjoint_tcbuffer_tcbuffer. -func TdisjointTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TdisjointTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdisjoint_tcbuffer_tcbuffer(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TintersectsCbufferTcbuffer wraps MEOS C function tintersects_cbuffer_tcbuffer. -func TintersectsCbufferTcbuffer(cb *Cbuffer, temp *Temporal) *Temporal { +func TintersectsCbufferTcbuffer(cb *Cbuffer, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tintersects_cbuffer_tcbuffer(cb._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TintersectsGeoTcbuffer wraps MEOS C function tintersects_geo_tcbuffer. -func TintersectsGeoTcbuffer(gs *Geom, temp *Temporal) *Temporal { +func TintersectsGeoTcbuffer(gs *Geom, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tintersects_geo_tcbuffer(gs._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TintersectsTcbufferGeo wraps MEOS C function tintersects_tcbuffer_geo. -func TintersectsTcbufferGeo(temp *Temporal, gs *Geom) *Temporal { +func TintersectsTcbufferGeo(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tintersects_tcbuffer_geo(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TintersectsTcbufferCbuffer wraps MEOS C function tintersects_tcbuffer_cbuffer. -func TintersectsTcbufferCbuffer(temp *Temporal, cb *Cbuffer) *Temporal { +func TintersectsTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tintersects_tcbuffer_cbuffer(temp._inner, cb._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TintersectsTcbufferTcbuffer wraps MEOS C function tintersects_tcbuffer_tcbuffer. -func TintersectsTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TintersectsTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tintersects_tcbuffer_tcbuffer(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TtouchesGeoTcbuffer wraps MEOS C function ttouches_geo_tcbuffer. -func TtouchesGeoTcbuffer(gs *Geom, temp *Temporal) *Temporal { +func TtouchesGeoTcbuffer(gs *Geom, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.ttouches_geo_tcbuffer(gs._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TtouchesTcbufferGeo wraps MEOS C function ttouches_tcbuffer_geo. -func TtouchesTcbufferGeo(temp *Temporal, gs *Geom) *Temporal { +func TtouchesTcbufferGeo(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.ttouches_tcbuffer_geo(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TtouchesCbufferTcbuffer wraps MEOS C function ttouches_cbuffer_tcbuffer. -func TtouchesCbufferTcbuffer(cb *Cbuffer, temp *Temporal) *Temporal { +func TtouchesCbufferTcbuffer(cb *Cbuffer, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.ttouches_cbuffer_tcbuffer(cb._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TtouchesTcbufferCbuffer wraps MEOS C function ttouches_tcbuffer_cbuffer. -func TtouchesTcbufferCbuffer(temp *Temporal, cb *Cbuffer) *Temporal { +func TtouchesTcbufferCbuffer(temp *Temporal, cb *Cbuffer) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.ttouches_tcbuffer_cbuffer(temp._inner, cb._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TtouchesTcbufferTcbuffer wraps MEOS C function ttouches_tcbuffer_tcbuffer. -func TtouchesTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TtouchesTcbufferTcbuffer(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.ttouches_tcbuffer_tcbuffer(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } diff --git a/functions/meos_meos_geo.go b/functions/meos_meos_geo.go index 74c3cc7..bcc6e69 100644 --- a/functions/meos_meos_geo.go +++ b/functions/meos_meos_geo.go @@ -86,1624 +86,2512 @@ import ( var _ = unsafe.Pointer(nil) // Box3dMake wraps MEOS C function box3d_make. -func Box3dMake(xmin float64, xmax float64, ymin float64, ymax float64, zmin float64, zmax float64, srid int32) *Box3D { +func Box3dMake(xmin float64, xmax float64, ymin float64, ymax float64, zmin float64, zmax float64, srid int32) (_r0 *Box3D, _err error) { + C.meos_errno_reset() _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)) - return &Box3D{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Box3D{_inner: _cret}, nil } // Box3dIn wraps MEOS C function box3d_in. -func Box3dIn(str string) *Box3D { +func Box3dIn(str string) (_r0 *Box3D, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.box3d_in(_c_str) - return &Box3D{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Box3D{_inner: _cret}, nil } // Box3dOut wraps MEOS C function box3d_out. -func Box3dOut(box *Box3D, maxdd int) string { +func Box3dOut(box *Box3D, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.box3d_out(box._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // GboxMake wraps MEOS C function gbox_make. -func GboxMake(hasz bool, hasm bool, geodetic bool, xmin float64, xmax float64, ymin float64, ymax float64, zmin float64, zmax float64, mmin float64, mmax float64) *GBox { +func GboxMake(hasz bool, hasm bool, geodetic bool, xmin float64, xmax float64, ymin float64, ymax float64, zmin float64, zmax float64, mmin float64, mmax float64) (_r0 *GBox, _err error) { + C.meos_errno_reset() _cret := C.gbox_make(C.bool(hasz), C.bool(hasm), C.bool(geodetic), C.double(xmin), C.double(xmax), C.double(ymin), C.double(ymax), C.double(zmin), C.double(zmax), C.double(mmin), C.double(mmax)) - return &GBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &GBox{_inner: _cret}, nil } // GboxIn wraps MEOS C function gbox_in. -func GboxIn(str string) *GBox { +func GboxIn(str string) (_r0 *GBox, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.gbox_in(_c_str) - return &GBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &GBox{_inner: _cret}, nil } // GboxOut wraps MEOS C function gbox_out. -func GboxOut(box *GBox, maxdd int) string { +func GboxOut(box *GBox, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.gbox_out(box._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // GeoAsEWKB wraps MEOS C function geo_as_ewkb. -func GeoAsEWKB(gs *Geom, endian string, size unsafe.Pointer) unsafe.Pointer { +func GeoAsEWKB(gs *Geom, endian string, size unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { _c_endian := C.CString(endian) defer C.free(unsafe.Pointer(_c_endian)) + C.meos_errno_reset() _cret := C.geo_as_ewkb(gs._inner, _c_endian, (*C.size_t)(unsafe.Pointer(size))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // GeoAsEWKT wraps MEOS C function geo_as_ewkt. -func GeoAsEWKT(gs *Geom, precision int) string { +func GeoAsEWKT(gs *Geom, precision int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.geo_as_ewkt(gs._inner, C.int(precision)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // GeoAsGeojson wraps MEOS C function geo_as_geojson. -func GeoAsGeojson(gs *Geom, option int, precision int, srs string) string { +func GeoAsGeojson(gs *Geom, option int, precision int, srs string) (_r0 string, _err error) { _c_srs := C.CString(srs) defer C.free(unsafe.Pointer(_c_srs)) + C.meos_errno_reset() _cret := C.geo_as_geojson(gs._inner, C.int(option), C.int(precision), _c_srs) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // GeoAsHexewkb wraps MEOS C function geo_as_hexewkb. -func GeoAsHexewkb(gs *Geom, endian string) string { +func GeoAsHexewkb(gs *Geom, endian string) (_r0 string, _err error) { _c_endian := C.CString(endian) defer C.free(unsafe.Pointer(_c_endian)) + C.meos_errno_reset() _cret := C.geo_as_hexewkb(gs._inner, _c_endian) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // GeoAsText wraps MEOS C function geo_as_text. -func GeoAsText(gs *Geom, precision int) string { +func GeoAsText(gs *Geom, precision int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.geo_as_text(gs._inner, C.int(precision)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // GeoFromEWKB wraps MEOS C function geo_from_ewkb. -func GeoFromEWKB(wkb unsafe.Pointer, wkb_size uint, srid int32) *Geom { +func GeoFromEWKB(wkb unsafe.Pointer, wkb_size uint, srid int32) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geo_from_ewkb((*C.uint8_t)(unsafe.Pointer(wkb)), C.size_t(wkb_size), C.int32_t(srid)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeoFromGeojson wraps MEOS C function geo_from_geojson. -func GeoFromGeojson(geojson string) *Geom { +func GeoFromGeojson(geojson string) (_r0 *Geom, _err error) { _c_geojson := C.CString(geojson) defer C.free(unsafe.Pointer(_c_geojson)) + C.meos_errno_reset() _cret := C.geo_from_geojson(_c_geojson) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeoFromText wraps MEOS C function geo_from_text. -func GeoFromText(wkt string, srid int32) *Geom { +func GeoFromText(wkt string, srid int32) (_r0 *Geom, _err error) { _c_wkt := C.CString(wkt) defer C.free(unsafe.Pointer(_c_wkt)) + C.meos_errno_reset() _cret := C.geo_from_text(_c_wkt, C.int32_t(srid)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeoOut wraps MEOS C function geo_out. -func GeoOut(gs *Geom) string { +func GeoOut(gs *Geom) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.geo_out(gs._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // GeogFromHexewkb wraps MEOS C function geog_from_hexewkb. -func GeogFromHexewkb(wkt string) *Geom { +func GeogFromHexewkb(wkt string) (_r0 *Geom, _err error) { _c_wkt := C.CString(wkt) defer C.free(unsafe.Pointer(_c_wkt)) + C.meos_errno_reset() _cret := C.geog_from_hexewkb(_c_wkt) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeogIn wraps MEOS C function geog_in. -func GeogIn(str string, typmod int32) *Geom { +func GeogIn(str string, typmod int32) (_r0 *Geom, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.geog_in(_c_str, C.int32(typmod)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeomFromHexewkb wraps MEOS C function geom_from_hexewkb. -func GeomFromHexewkb(wkt string) *Geom { +func GeomFromHexewkb(wkt string) (_r0 *Geom, _err error) { _c_wkt := C.CString(wkt) defer C.free(unsafe.Pointer(_c_wkt)) + C.meos_errno_reset() _cret := C.geom_from_hexewkb(_c_wkt) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeomIn wraps MEOS C function geom_in. -func GeomIn(str string, typmod int32) *Geom { +func GeomIn(str string, typmod int32) (_r0 *Geom, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.geom_in(_c_str, C.int32(typmod)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeoCopy wraps MEOS C function geo_copy. -func GeoCopy(gs *Geom) *Geom { +func GeoCopy(gs *Geom) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geo_copy(gs._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeogpointMake2d wraps MEOS C function geogpoint_make2d. -func GeogpointMake2d(srid int32, x float64, y float64) *Geom { +func GeogpointMake2d(srid int32, x float64, y float64) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geogpoint_make2d(C.int32_t(srid), C.double(x), C.double(y)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeogpointMake3dz wraps MEOS C function geogpoint_make3dz. -func GeogpointMake3dz(srid int32, x float64, y float64, z float64) *Geom { +func GeogpointMake3dz(srid int32, x float64, y float64, z float64) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geogpoint_make3dz(C.int32_t(srid), C.double(x), C.double(y), C.double(z)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeompointMake2d wraps MEOS C function geompoint_make2d. -func GeompointMake2d(srid int32, x float64, y float64) *Geom { +func GeompointMake2d(srid int32, x float64, y float64) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geompoint_make2d(C.int32_t(srid), C.double(x), C.double(y)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeompointMake3dz wraps MEOS C function geompoint_make3dz. -func GeompointMake3dz(srid int32, x float64, y float64, z float64) *Geom { +func GeompointMake3dz(srid int32, x float64, y float64, z float64) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geompoint_make3dz(C.int32_t(srid), C.double(x), C.double(y), C.double(z)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeomToGeog wraps MEOS C function geom_to_geog. -func GeomToGeog(geom *Geom) *Geom { +func GeomToGeog(geom *Geom) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geom_to_geog(geom._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeogToGeom wraps MEOS C function geog_to_geom. -func GeogToGeom(geog *Geom) *Geom { +func GeogToGeom(geog *Geom) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geog_to_geom(geog._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeoIsEmpty wraps MEOS C function geo_is_empty. -func GeoIsEmpty(gs *Geom) bool { +func GeoIsEmpty(gs *Geom) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.geo_is_empty(gs._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // GeoIsUnitary wraps MEOS C function geo_is_unitary. -func GeoIsUnitary(gs *Geom) bool { +func GeoIsUnitary(gs *Geom) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.geo_is_unitary(gs._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // GeoTypename wraps MEOS C function geo_typename. -func GeoTypename(type_ int) string { +func GeoTypename(type_ int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.geo_typename(C.int(type_)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // GeogArea wraps MEOS C function geog_area. -func GeogArea(gs *Geom, use_spheroid bool) float64 { +func GeogArea(gs *Geom, use_spheroid bool) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.geog_area(gs._inner, C.bool(use_spheroid)) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // GeogCentroid wraps MEOS C function geog_centroid. -func GeogCentroid(gs *Geom, use_spheroid bool) *Geom { +func GeogCentroid(gs *Geom, use_spheroid bool) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geog_centroid(gs._inner, C.bool(use_spheroid)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeogLength wraps MEOS C function geog_length. -func GeogLength(gs *Geom, use_spheroid bool) float64 { +func GeogLength(gs *Geom, use_spheroid bool) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.geog_length(gs._inner, C.bool(use_spheroid)) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // GeogPerimeter wraps MEOS C function geog_perimeter. -func GeogPerimeter(gs *Geom, use_spheroid bool) float64 { +func GeogPerimeter(gs *Geom, use_spheroid bool) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.geog_perimeter(gs._inner, C.bool(use_spheroid)) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // GeomAzimuth wraps MEOS C function geom_azimuth. -func GeomAzimuth(gs1 *Geom, gs2 *Geom) (bool, float64) { +func GeomAzimuth(gs1 *Geom, gs2 *Geom) (_r0 bool, _r1 float64, _err error) { var _out_result C.double + C.meos_errno_reset() _cret := C.geom_azimuth(gs1._inner, gs2._inner, &_out_result) - return bool(_cret), float64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), float64(_out_result), nil } // GeomLength wraps MEOS C function geom_length. -func GeomLength(gs *Geom) float64 { +func GeomLength(gs *Geom) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.geom_length(gs._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // GeomPerimeter wraps MEOS C function geom_perimeter. -func GeomPerimeter(gs *Geom) float64 { +func GeomPerimeter(gs *Geom) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.geom_perimeter(gs._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // LineNumpoints wraps MEOS C function line_numpoints. -func LineNumpoints(gs *Geom) int { +func LineNumpoints(gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.line_numpoints(gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // LinePointN wraps MEOS C function line_point_n. -func LinePointN(geom *Geom, n int) *Geom { +func LinePointN(geom *Geom, n int) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.line_point_n(geom._inner, C.int(n)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeoReverse wraps MEOS C function geo_reverse. -func GeoReverse(gs *Geom) *Geom { +func GeoReverse(gs *Geom) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geo_reverse(gs._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeoRound wraps MEOS C function geo_round. -func GeoRound(gs *Geom, maxdd int) *Geom { +func GeoRound(gs *Geom, maxdd int) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geo_round(gs._inner, C.int(maxdd)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeoSetSRID wraps MEOS C function geo_set_srid. -func GeoSetSRID(gs *Geom, srid int32) *Geom { +func GeoSetSRID(gs *Geom, srid int32) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geo_set_srid(gs._inner, C.int32_t(srid)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeoSRID wraps MEOS C function geo_srid. -func GeoSRID(gs *Geom) int32 { +func GeoSRID(gs *Geom) (_r0 int32, _err error) { + C.meos_errno_reset() _cret := C.geo_srid(gs._inner) - return int32(_cret) + if _err = meosError(); _err != nil { + return + } + return int32(_cret), nil } // GeoTransform wraps MEOS C function geo_transform. -func GeoTransform(geom *Geom, srid_to int32) *Geom { +func GeoTransform(geom *Geom, srid_to int32) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geo_transform(geom._inner, C.int32_t(srid_to)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeoTransformPipeline wraps MEOS C function geo_transform_pipeline. -func GeoTransformPipeline(gs *Geom, pipeline string, srid_to int32, is_forward bool) *Geom { +func GeoTransformPipeline(gs *Geom, pipeline string, srid_to int32, is_forward bool) (_r0 *Geom, _err error) { _c_pipeline := C.CString(pipeline) defer C.free(unsafe.Pointer(_c_pipeline)) + C.meos_errno_reset() _cret := C.geo_transform_pipeline(gs._inner, _c_pipeline, C.int32_t(srid_to), C.bool(is_forward)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeoCollectGarray wraps MEOS C function geo_collect_garray. -func GeoCollectGarray(gsarr unsafe.Pointer, count int) *Geom { +func GeoCollectGarray(gsarr unsafe.Pointer, count int) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geo_collect_garray((**C.GSERIALIZED)(unsafe.Pointer(gsarr)), C.int(count)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeoMakelineGarray wraps MEOS C function geo_makeline_garray. -func GeoMakelineGarray(gsarr unsafe.Pointer, count int) *Geom { +func GeoMakelineGarray(gsarr unsafe.Pointer, count int) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geo_makeline_garray((**C.GSERIALIZED)(unsafe.Pointer(gsarr)), C.int(count)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeoNumPoints wraps MEOS C function geo_num_points. -func GeoNumPoints(gs *Geom) int { +func GeoNumPoints(gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.geo_num_points(gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // GeoNumGeos wraps MEOS C function geo_num_geos. -func GeoNumGeos(gs *Geom) int { +func GeoNumGeos(gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.geo_num_geos(gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // GeoGeoN wraps MEOS C function geo_geo_n. -func GeoGeoN(geom *Geom, n int) *Geom { +func GeoGeoN(geom *Geom, n int) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geo_geo_n(geom._inner, C.int(n)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeoPointarr wraps MEOS C function geo_pointarr. -func GeoPointarr(gs *Geom, count unsafe.Pointer) unsafe.Pointer { +func GeoPointarr(gs *Geom, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.geo_pointarr(gs._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // GeoPoints wraps MEOS C function geo_points. -func GeoPoints(gs *Geom) *Geom { +func GeoPoints(gs *Geom) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geo_points(gs._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeomArrayUnion wraps MEOS C function geom_array_union. -func GeomArrayUnion(gsarr unsafe.Pointer, count int) *Geom { +func GeomArrayUnion(gsarr unsafe.Pointer, count int) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geom_array_union((**C.GSERIALIZED)(unsafe.Pointer(gsarr)), C.int(count)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeomBoundary wraps MEOS C function geom_boundary. -func GeomBoundary(gs *Geom) *Geom { +func GeomBoundary(gs *Geom) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geom_boundary(gs._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeomBuffer wraps MEOS C function geom_buffer. -func GeomBuffer(gs *Geom, size float64, params string) *Geom { +func GeomBuffer(gs *Geom, size float64, params string) (_r0 *Geom, _err error) { _c_params := C.CString(params) defer C.free(unsafe.Pointer(_c_params)) + C.meos_errno_reset() _cret := C.geom_buffer(gs._inner, C.double(size), _c_params) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeomCentroid wraps MEOS C function geom_centroid. -func GeomCentroid(gs *Geom) *Geom { +func GeomCentroid(gs *Geom) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geom_centroid(gs._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeomConvexHull wraps MEOS C function geom_convex_hull. -func GeomConvexHull(gs *Geom) *Geom { +func GeomConvexHull(gs *Geom) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geom_convex_hull(gs._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeomDifference2d wraps MEOS C function geom_difference2d. -func GeomDifference2d(gs1 *Geom, gs2 *Geom) *Geom { +func GeomDifference2d(gs1 *Geom, gs2 *Geom) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geom_difference2d(gs1._inner, gs2._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeomIntersection2d wraps MEOS C function geom_intersection2d. -func GeomIntersection2d(gs1 *Geom, gs2 *Geom) *Geom { +func GeomIntersection2d(gs1 *Geom, gs2 *Geom) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geom_intersection2d(gs1._inner, gs2._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeomIntersection2dColl wraps MEOS C function geom_intersection2d_coll. -func GeomIntersection2dColl(gs1 *Geom, gs2 *Geom) *Geom { +func GeomIntersection2dColl(gs1 *Geom, gs2 *Geom) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geom_intersection2d_coll(gs1._inner, gs2._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeomMinBoundingRadius wraps MEOS C function geom_min_bounding_radius. -func GeomMinBoundingRadius(geom *Geom, radius unsafe.Pointer) *Geom { +func GeomMinBoundingRadius(geom *Geom, radius unsafe.Pointer) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geom_min_bounding_radius(geom._inner, (*C.double)(unsafe.Pointer(radius))) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeomShortestline2d wraps MEOS C function geom_shortestline2d. -func GeomShortestline2d(gs1 *Geom, gs2 *Geom) *Geom { +func GeomShortestline2d(gs1 *Geom, gs2 *Geom) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geom_shortestline2d(gs1._inner, gs2._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeomShortestline3d wraps MEOS C function geom_shortestline3d. -func GeomShortestline3d(gs1 *Geom, gs2 *Geom) *Geom { +func GeomShortestline3d(gs1 *Geom, gs2 *Geom) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geom_shortestline3d(gs1._inner, gs2._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeomUnaryUnion wraps MEOS C function geom_unary_union. -func GeomUnaryUnion(gs *Geom, prec float64) *Geom { +func GeomUnaryUnion(gs *Geom, prec float64) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geom_unary_union(gs._inner, C.double(prec)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // LineInterpolatePoint wraps MEOS C function line_interpolate_point. -func LineInterpolatePoint(gs *Geom, distance_fraction float64, repeat bool) *Geom { +func LineInterpolatePoint(gs *Geom, distance_fraction float64, repeat bool) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.line_interpolate_point(gs._inner, C.double(distance_fraction), C.bool(repeat)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // LineLocatePoint wraps MEOS C function line_locate_point. -func LineLocatePoint(gs1 *Geom, gs2 *Geom) float64 { +func LineLocatePoint(gs1 *Geom, gs2 *Geom) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.line_locate_point(gs1._inner, gs2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // LineSubstring wraps MEOS C function line_substring. -func LineSubstring(gs *Geom, from float64, to float64) *Geom { +func LineSubstring(gs *Geom, from float64, to float64) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.line_substring(gs._inner, C.double(from), C.double(to)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeogDwithin wraps MEOS C function geog_dwithin. -func GeogDwithin(g1 *Geom, g2 *Geom, tolerance float64, use_spheroid bool) bool { +func GeogDwithin(g1 *Geom, g2 *Geom, tolerance float64, use_spheroid bool) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.geog_dwithin(g1._inner, g2._inner, C.double(tolerance), C.bool(use_spheroid)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // GeogIntersects wraps MEOS C function geog_intersects. -func GeogIntersects(gs1 *Geom, gs2 *Geom, use_spheroid bool) bool { +func GeogIntersects(gs1 *Geom, gs2 *Geom, use_spheroid bool) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.geog_intersects(gs1._inner, gs2._inner, C.bool(use_spheroid)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // GeomContains wraps MEOS C function geom_contains. -func GeomContains(gs1 *Geom, gs2 *Geom) bool { +func GeomContains(gs1 *Geom, gs2 *Geom) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.geom_contains(gs1._inner, gs2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // GeomCovers wraps MEOS C function geom_covers. -func GeomCovers(gs1 *Geom, gs2 *Geom) bool { +func GeomCovers(gs1 *Geom, gs2 *Geom) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.geom_covers(gs1._inner, gs2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // GeomDisjoint2d wraps MEOS C function geom_disjoint2d. -func GeomDisjoint2d(gs1 *Geom, gs2 *Geom) bool { +func GeomDisjoint2d(gs1 *Geom, gs2 *Geom) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.geom_disjoint2d(gs1._inner, gs2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // GeomDwithin wraps MEOS C function geom_dwithin. -func GeomDwithin(gs1 *Geom, gs2 *Geom, tolerance float64) bool { +func GeomDwithin(gs1 *Geom, gs2 *Geom, tolerance float64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.geom_dwithin(gs1._inner, gs2._inner, C.double(tolerance)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // GeomDwithin2d wraps MEOS C function geom_dwithin2d. -func GeomDwithin2d(gs1 *Geom, gs2 *Geom, tolerance float64) bool { +func GeomDwithin2d(gs1 *Geom, gs2 *Geom, tolerance float64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.geom_dwithin2d(gs1._inner, gs2._inner, C.double(tolerance)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // GeomDwithin3d wraps MEOS C function geom_dwithin3d. -func GeomDwithin3d(gs1 *Geom, gs2 *Geom, tolerance float64) bool { +func GeomDwithin3d(gs1 *Geom, gs2 *Geom, tolerance float64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.geom_dwithin3d(gs1._inner, gs2._inner, C.double(tolerance)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // GeomIntersects wraps MEOS C function geom_intersects. -func GeomIntersects(gs1 *Geom, gs2 *Geom) bool { +func GeomIntersects(gs1 *Geom, gs2 *Geom) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.geom_intersects(gs1._inner, gs2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // GeomIntersects2d wraps MEOS C function geom_intersects2d. -func GeomIntersects2d(gs1 *Geom, gs2 *Geom) bool { +func GeomIntersects2d(gs1 *Geom, gs2 *Geom) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.geom_intersects2d(gs1._inner, gs2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // GeomIntersects3d wraps MEOS C function geom_intersects3d. -func GeomIntersects3d(gs1 *Geom, gs2 *Geom) bool { +func GeomIntersects3d(gs1 *Geom, gs2 *Geom) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.geom_intersects3d(gs1._inner, gs2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // GeomRelatePattern wraps MEOS C function geom_relate_pattern. -func GeomRelatePattern(gs1 *Geom, gs2 *Geom, patt string) bool { +func GeomRelatePattern(gs1 *Geom, gs2 *Geom, patt string) (_r0 bool, _err error) { _c_patt := C.CString(patt) defer C.free(unsafe.Pointer(_c_patt)) + C.meos_errno_reset() _cret := C.geom_relate_pattern(gs1._inner, gs2._inner, _c_patt) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // GeomTouches wraps MEOS C function geom_touches. -func GeomTouches(gs1 *Geom, gs2 *Geom) bool { +func GeomTouches(gs1 *Geom, gs2 *Geom) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.geom_touches(gs1._inner, gs2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // GeoStboxes wraps MEOS C function geo_stboxes. -func GeoStboxes(gs *Geom, count unsafe.Pointer) *STBox { +func GeoStboxes(gs *Geom, count unsafe.Pointer) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.geo_stboxes(gs._inner, (*C.int)(unsafe.Pointer(count))) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // GeoSplitEachNStboxes wraps MEOS C function geo_split_each_n_stboxes. -func GeoSplitEachNStboxes(gs *Geom, elem_count int, count unsafe.Pointer) *STBox { +func GeoSplitEachNStboxes(gs *Geom, elem_count int, count unsafe.Pointer) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.geo_split_each_n_stboxes(gs._inner, C.int(elem_count), (*C.int)(unsafe.Pointer(count))) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // GeoSplitNStboxes wraps MEOS C function geo_split_n_stboxes. -func GeoSplitNStboxes(gs *Geom, box_count int, count unsafe.Pointer) *STBox { +func GeoSplitNStboxes(gs *Geom, box_count int, count unsafe.Pointer) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.geo_split_n_stboxes(gs._inner, C.int(box_count), (*C.int)(unsafe.Pointer(count))) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // GeogDistance wraps MEOS C function geog_distance. -func GeogDistance(g1 *Geom, g2 *Geom) float64 { +func GeogDistance(g1 *Geom, g2 *Geom) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.geog_distance(g1._inner, g2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // GeomDistance2d wraps MEOS C function geom_distance2d. -func GeomDistance2d(gs1 *Geom, gs2 *Geom) float64 { +func GeomDistance2d(gs1 *Geom, gs2 *Geom) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.geom_distance2d(gs1._inner, gs2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // GeomDistance3d wraps MEOS C function geom_distance3d. -func GeomDistance3d(gs1 *Geom, gs2 *Geom) float64 { +func GeomDistance3d(gs1 *Geom, gs2 *Geom) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.geom_distance3d(gs1._inner, gs2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // GeoEquals wraps MEOS C function geo_equals. -func GeoEquals(gs1 *Geom, gs2 *Geom) int { +func GeoEquals(gs1 *Geom, gs2 *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.geo_equals(gs1._inner, gs2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // GeoSame wraps MEOS C function geo_same. -func GeoSame(gs1 *Geom, gs2 *Geom) bool { +func GeoSame(gs1 *Geom, gs2 *Geom) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.geo_same(gs1._inner, gs2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // GeogsetIn wraps MEOS C function geogset_in. -func GeogsetIn(str string) *Set { +func GeogsetIn(str string) (_r0 *Set, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.geogset_in(_c_str) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // GeomsetIn wraps MEOS C function geomset_in. -func GeomsetIn(str string) *Set { +func GeomsetIn(str string) (_r0 *Set, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.geomset_in(_c_str) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // SpatialsetOut wraps MEOS C function spatialset_out. -func SpatialsetOut(s *Set, maxdd int) string { +func SpatialsetOut(s *Set, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.spatialset_out(s._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // SpatialsetAsText wraps MEOS C function spatialset_as_text. -func SpatialsetAsText(set *Set, maxdd int) string { +func SpatialsetAsText(set *Set, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.spatialset_as_text(set._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // SpatialsetAsEWKT wraps MEOS C function spatialset_as_ewkt. -func SpatialsetAsEWKT(set *Set, maxdd int) string { +func SpatialsetAsEWKT(set *Set, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.spatialset_as_ewkt(set._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // GeosetMake wraps MEOS C function geoset_make. -func GeosetMake(values unsafe.Pointer, count int) *Set { +func GeosetMake(values unsafe.Pointer, count int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.geoset_make((**C.GSERIALIZED)(unsafe.Pointer(values)), C.int(count)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // GeoToSet wraps MEOS C function geo_to_set. -func GeoToSet(gs *Geom) *Set { +func GeoToSet(gs *Geom) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.geo_to_set(gs._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // GeosetEndValue wraps MEOS C function geoset_end_value. -func GeosetEndValue(s *Set) *Geom { +func GeosetEndValue(s *Set) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geoset_end_value(s._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeosetStartValue wraps MEOS C function geoset_start_value. -func GeosetStartValue(s *Set) *Geom { +func GeosetStartValue(s *Set) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.geoset_start_value(s._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeosetValueN wraps MEOS C function geoset_value_n. -func GeosetValueN(s *Set, n int) (bool, *Geom) { +func GeosetValueN(s *Set, n int) (_r0 bool, _r1 *Geom, _err error) { var _out_result *C.GSERIALIZED + C.meos_errno_reset() _cret := C.geoset_value_n(s._inner, C.int(n), &_out_result) - return bool(_cret), &Geom{_inner: _out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Geom{_inner: _out_result}, nil } // GeosetValues wraps MEOS C function geoset_values. -func GeosetValues(s *Set, count unsafe.Pointer) unsafe.Pointer { +func GeosetValues(s *Set, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.geoset_values(s._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // ContainedGeoSet wraps MEOS C function contained_geo_set. -func ContainedGeoSet(gs *Geom, s *Set) bool { +func ContainedGeoSet(gs *Geom, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_geo_set(gs._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSetGeo wraps MEOS C function contains_set_geo. -func ContainsSetGeo(s *Set, gs *Geom) bool { +func ContainsSetGeo(s *Set, gs *Geom) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_set_geo(s._inner, gs._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // GeoUnionTransfn wraps MEOS C function geo_union_transfn. -func GeoUnionTransfn(state *Set, gs *Geom) *Set { +func GeoUnionTransfn(state *Set, gs *Geom) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.geo_union_transfn(state._inner, gs._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntersectionGeoSet wraps MEOS C function intersection_geo_set. -func IntersectionGeoSet(gs *Geom, s *Set) *Set { +func IntersectionGeoSet(gs *Geom, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_geo_set(gs._inner, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntersectionSetGeo wraps MEOS C function intersection_set_geo. -func IntersectionSetGeo(s *Set, gs *Geom) *Set { +func IntersectionSetGeo(s *Set, gs *Geom) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_set_geo(s._inner, gs._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusGeoSet wraps MEOS C function minus_geo_set. -func MinusGeoSet(gs *Geom, s *Set) *Set { +func MinusGeoSet(gs *Geom, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_geo_set(gs._inner, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusSetGeo wraps MEOS C function minus_set_geo. -func MinusSetGeo(s *Set, gs *Geom) *Set { +func MinusSetGeo(s *Set, gs *Geom) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_set_geo(s._inner, gs._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionGeoSet wraps MEOS C function union_geo_set. -func UnionGeoSet(gs *Geom, s *Set) *Set { +func UnionGeoSet(gs *Geom, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_geo_set(gs._inner, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionSetGeo wraps MEOS C function union_set_geo. -func UnionSetGeo(s *Set, gs *Geom) *Set { +func UnionSetGeo(s *Set, gs *Geom) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_set_geo(s._inner, gs._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // SpatialsetSetSRID wraps MEOS C function spatialset_set_srid. -func SpatialsetSetSRID(s *Set, srid int32) *Set { +func SpatialsetSetSRID(s *Set, srid int32) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.spatialset_set_srid(s._inner, C.int32_t(srid)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // SpatialsetSRID wraps MEOS C function spatialset_srid. -func SpatialsetSRID(s *Set) int32 { +func SpatialsetSRID(s *Set) (_r0 int32, _err error) { + C.meos_errno_reset() _cret := C.spatialset_srid(s._inner) - return int32(_cret) + if _err = meosError(); _err != nil { + return + } + return int32(_cret), nil } // SpatialsetTransform wraps MEOS C function spatialset_transform. -func SpatialsetTransform(s *Set, srid int32) *Set { +func SpatialsetTransform(s *Set, srid int32) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.spatialset_transform(s._inner, C.int32_t(srid)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // SpatialsetTransformPipeline wraps MEOS C function spatialset_transform_pipeline. -func SpatialsetTransformPipeline(s *Set, pipelinestr string, srid int32, is_forward bool) *Set { +func SpatialsetTransformPipeline(s *Set, pipelinestr string, srid int32, is_forward bool) (_r0 *Set, _err error) { _c_pipelinestr := C.CString(pipelinestr) defer C.free(unsafe.Pointer(_c_pipelinestr)) + C.meos_errno_reset() _cret := C.spatialset_transform_pipeline(s._inner, _c_pipelinestr, C.int32_t(srid), C.bool(is_forward)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // STBOXAsHexwkb wraps MEOS C function stbox_as_hexwkb. -func STBOXAsHexwkb(box *STBox, variant uint8, size_out unsafe.Pointer) string { +func STBOXAsHexwkb(box *STBox, variant uint8, size_out unsafe.Pointer) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.stbox_as_hexwkb(box._inner, C.uint8_t(variant), (*C.size_t)(unsafe.Pointer(size_out))) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // STBOXAsWKB wraps MEOS C function stbox_as_wkb. -func STBOXAsWKB(box *STBox, variant uint8, size_out unsafe.Pointer) unsafe.Pointer { +func STBOXAsWKB(box *STBox, variant uint8, size_out unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.stbox_as_wkb(box._inner, C.uint8_t(variant), (*C.size_t)(unsafe.Pointer(size_out))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // STBOXFromHexwkb wraps MEOS C function stbox_from_hexwkb. -func STBOXFromHexwkb(hexwkb string) *STBox { +func STBOXFromHexwkb(hexwkb string) (_r0 *STBox, _err error) { _c_hexwkb := C.CString(hexwkb) defer C.free(unsafe.Pointer(_c_hexwkb)) + C.meos_errno_reset() _cret := C.stbox_from_hexwkb(_c_hexwkb) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // STBOXFromWKB wraps MEOS C function stbox_from_wkb. -func STBOXFromWKB(wkb unsafe.Pointer, size uint) *STBox { +func STBOXFromWKB(wkb unsafe.Pointer, size uint) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.stbox_from_wkb((*C.uint8_t)(unsafe.Pointer(wkb)), C.size_t(size)) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // STBOXIn wraps MEOS C function stbox_in. -func STBOXIn(str string) *STBox { +func STBOXIn(str string) (_r0 *STBox, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.stbox_in(_c_str) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // STBOXOut wraps MEOS C function stbox_out. -func STBOXOut(box *STBox, maxdd int) string { +func STBOXOut(box *STBox, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.stbox_out(box._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // GeoTimestamptzToSTBOX wraps MEOS C function geo_timestamptz_to_stbox. -func GeoTimestamptzToSTBOX(gs *Geom, t int64) *STBox { +func GeoTimestamptzToSTBOX(gs *Geom, t int64) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.geo_timestamptz_to_stbox(gs._inner, C.TimestampTz(t)) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // GeoTstzspanToSTBOX wraps MEOS C function geo_tstzspan_to_stbox. -func GeoTstzspanToSTBOX(gs *Geom, s *Span) *STBox { +func GeoTstzspanToSTBOX(gs *Geom, s *Span) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.geo_tstzspan_to_stbox(gs._inner, s._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // STBOXCopy wraps MEOS C function stbox_copy. -func STBOXCopy(box *STBox) *STBox { +func STBOXCopy(box *STBox) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.stbox_copy(box._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // STBOXMake wraps MEOS C function stbox_make. -func STBOXMake(hasx bool, hasz bool, geodetic bool, srid int32, xmin float64, xmax float64, ymin float64, ymax float64, zmin float64, zmax float64, s *Span) *STBox { +func STBOXMake(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) { + C.meos_errno_reset() _cret := C.stbox_make(C.bool(hasx), C.bool(hasz), C.bool(geodetic), C.int32_t(srid), C.double(xmin), C.double(xmax), C.double(ymin), C.double(ymax), C.double(zmin), C.double(zmax), s._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // GeoToSTBOX wraps MEOS C function geo_to_stbox. -func GeoToSTBOX(gs *Geom) *STBox { +func GeoToSTBOX(gs *Geom) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.geo_to_stbox(gs._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // SpatialsetToSTBOX wraps MEOS C function spatialset_to_stbox. -func SpatialsetToSTBOX(s *Set) *STBox { +func SpatialsetToSTBOX(s *Set) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.spatialset_to_stbox(s._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // STBOXToBox3d wraps MEOS C function stbox_to_box3d. -func STBOXToBox3d(box *STBox) *Box3D { +func STBOXToBox3d(box *STBox) (_r0 *Box3D, _err error) { + C.meos_errno_reset() _cret := C.stbox_to_box3d(box._inner) - return &Box3D{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Box3D{_inner: _cret}, nil } // STBOXToGbox wraps MEOS C function stbox_to_gbox. -func STBOXToGbox(box *STBox) *GBox { +func STBOXToGbox(box *STBox) (_r0 *GBox, _err error) { + C.meos_errno_reset() _cret := C.stbox_to_gbox(box._inner) - return &GBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &GBox{_inner: _cret}, nil } // STBOXToGeo wraps MEOS C function stbox_to_geo. -func STBOXToGeo(box *STBox) *Geom { +func STBOXToGeo(box *STBox) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.stbox_to_geo(box._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // STBOXToTstzspan wraps MEOS C function stbox_to_tstzspan. -func STBOXToTstzspan(box *STBox) *Span { +func STBOXToTstzspan(box *STBox) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.stbox_to_tstzspan(box._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // TimestamptzToSTBOX wraps MEOS C function timestamptz_to_stbox. -func TimestamptzToSTBOX(t int64) *STBox { +func TimestamptzToSTBOX(t int64) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.timestamptz_to_stbox(C.TimestampTz(t)) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // TstzsetToSTBOX wraps MEOS C function tstzset_to_stbox. -func TstzsetToSTBOX(s *Set) *STBox { +func TstzsetToSTBOX(s *Set) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.tstzset_to_stbox(s._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // TstzspanToSTBOX wraps MEOS C function tstzspan_to_stbox. -func TstzspanToSTBOX(s *Span) *STBox { +func TstzspanToSTBOX(s *Span) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.tstzspan_to_stbox(s._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // TstzspansetToSTBOX wraps MEOS C function tstzspanset_to_stbox. -func TstzspansetToSTBOX(ss *SpanSet) *STBox { +func TstzspansetToSTBOX(ss *SpanSet) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.tstzspanset_to_stbox(ss._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // STBOXArea wraps MEOS C function stbox_area. -func STBOXArea(box *STBox, spheroid bool) float64 { +func STBOXArea(box *STBox, spheroid bool) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.stbox_area(box._inner, C.bool(spheroid)) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // STBOXHash wraps MEOS C function stbox_hash. -func STBOXHash(box *STBox) uint32 { +func STBOXHash(box *STBox) (_r0 uint32, _err error) { + C.meos_errno_reset() _cret := C.stbox_hash(box._inner) - return uint32(_cret) + if _err = meosError(); _err != nil { + return + } + return uint32(_cret), nil } // STBOXHashExtended wraps MEOS C function stbox_hash_extended. -func STBOXHashExtended(box *STBox, seed uint64) uint64 { +func STBOXHashExtended(box *STBox, seed uint64) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.stbox_hash_extended(box._inner, C.uint64_t(seed)) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // STBOXHast wraps MEOS C function stbox_hast. -func STBOXHast(box *STBox) bool { +func STBOXHast(box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.stbox_hast(box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // STBOXHasx wraps MEOS C function stbox_hasx. -func STBOXHasx(box *STBox) bool { +func STBOXHasx(box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.stbox_hasx(box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // STBOXHasz wraps MEOS C function stbox_hasz. -func STBOXHasz(box *STBox) bool { +func STBOXHasz(box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.stbox_hasz(box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // STBOXIsgeodetic wraps MEOS C function stbox_isgeodetic. -func STBOXIsgeodetic(box *STBox) bool { +func STBOXIsgeodetic(box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.stbox_isgeodetic(box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // STBOXPerimeter wraps MEOS C function stbox_perimeter. -func STBOXPerimeter(box *STBox, spheroid bool) float64 { +func STBOXPerimeter(box *STBox, spheroid bool) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.stbox_perimeter(box._inner, C.bool(spheroid)) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // STBOXTmax wraps MEOS C function stbox_tmax. -func STBOXTmax(box *STBox) (bool, int64) { +func STBOXTmax(box *STBox) (_r0 bool, _r1 int64, _err error) { var _out_result C.TimestampTz + C.meos_errno_reset() _cret := C.stbox_tmax(box._inner, &_out_result) - return bool(_cret), int64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), int64(_out_result), nil } // STBOXTmaxInc wraps MEOS C function stbox_tmax_inc. -func STBOXTmaxInc(box *STBox) (bool, bool) { +func STBOXTmaxInc(box *STBox) (_r0 bool, _r1 bool, _err error) { var _out_result C.bool + C.meos_errno_reset() _cret := C.stbox_tmax_inc(box._inner, &_out_result) - return bool(_cret), bool(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), bool(_out_result), nil } // STBOXTmin wraps MEOS C function stbox_tmin. -func STBOXTmin(box *STBox) (bool, int64) { +func STBOXTmin(box *STBox) (_r0 bool, _r1 int64, _err error) { var _out_result C.TimestampTz + C.meos_errno_reset() _cret := C.stbox_tmin(box._inner, &_out_result) - return bool(_cret), int64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), int64(_out_result), nil } // STBOXTminInc wraps MEOS C function stbox_tmin_inc. -func STBOXTminInc(box *STBox) (bool, bool) { +func STBOXTminInc(box *STBox) (_r0 bool, _r1 bool, _err error) { var _out_result C.bool + C.meos_errno_reset() _cret := C.stbox_tmin_inc(box._inner, &_out_result) - return bool(_cret), bool(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), bool(_out_result), nil } // STBOXVolume wraps MEOS C function stbox_volume. -func STBOXVolume(box *STBox) float64 { +func STBOXVolume(box *STBox) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.stbox_volume(box._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // STBOXXmax wraps MEOS C function stbox_xmax. -func STBOXXmax(box *STBox) (bool, float64) { +func STBOXXmax(box *STBox) (_r0 bool, _r1 float64, _err error) { var _out_result C.double + C.meos_errno_reset() _cret := C.stbox_xmax(box._inner, &_out_result) - return bool(_cret), float64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), float64(_out_result), nil } // STBOXXmin wraps MEOS C function stbox_xmin. -func STBOXXmin(box *STBox) (bool, float64) { +func STBOXXmin(box *STBox) (_r0 bool, _r1 float64, _err error) { var _out_result C.double + C.meos_errno_reset() _cret := C.stbox_xmin(box._inner, &_out_result) - return bool(_cret), float64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), float64(_out_result), nil } // STBOXYmax wraps MEOS C function stbox_ymax. -func STBOXYmax(box *STBox) (bool, float64) { +func STBOXYmax(box *STBox) (_r0 bool, _r1 float64, _err error) { var _out_result C.double + C.meos_errno_reset() _cret := C.stbox_ymax(box._inner, &_out_result) - return bool(_cret), float64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), float64(_out_result), nil } // STBOXYmin wraps MEOS C function stbox_ymin. -func STBOXYmin(box *STBox) (bool, float64) { +func STBOXYmin(box *STBox) (_r0 bool, _r1 float64, _err error) { var _out_result C.double + C.meos_errno_reset() _cret := C.stbox_ymin(box._inner, &_out_result) - return bool(_cret), float64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), float64(_out_result), nil } // STBOXZmax wraps MEOS C function stbox_zmax. -func STBOXZmax(box *STBox) (bool, float64) { +func STBOXZmax(box *STBox) (_r0 bool, _r1 float64, _err error) { var _out_result C.double + C.meos_errno_reset() _cret := C.stbox_zmax(box._inner, &_out_result) - return bool(_cret), float64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), float64(_out_result), nil } // STBOXZmin wraps MEOS C function stbox_zmin. -func STBOXZmin(box *STBox) (bool, float64) { +func STBOXZmin(box *STBox) (_r0 bool, _r1 float64, _err error) { var _out_result C.double + C.meos_errno_reset() _cret := C.stbox_zmin(box._inner, &_out_result) - return bool(_cret), float64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), float64(_out_result), nil } // STBOXExpandSpace wraps MEOS C function stbox_expand_space. -func STBOXExpandSpace(box *STBox, d float64) *STBox { +func STBOXExpandSpace(box *STBox, d float64) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.stbox_expand_space(box._inner, C.double(d)) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // STBOXExpandTime wraps MEOS C function stbox_expand_time. -func STBOXExpandTime(box *STBox, interv *Interval) *STBox { +func STBOXExpandTime(box *STBox, interv *Interval) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.stbox_expand_time(box._inner, interv._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // STBOXGetSpace wraps MEOS C function stbox_get_space. -func STBOXGetSpace(box *STBox) *STBox { +func STBOXGetSpace(box *STBox) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.stbox_get_space(box._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // STBOXQuadSplit wraps MEOS C function stbox_quad_split. -func STBOXQuadSplit(box *STBox, count unsafe.Pointer) *STBox { +func STBOXQuadSplit(box *STBox, count unsafe.Pointer) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.stbox_quad_split(box._inner, (*C.int)(unsafe.Pointer(count))) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // STBOXRound wraps MEOS C function stbox_round. -func STBOXRound(box *STBox, maxdd int) *STBox { +func STBOXRound(box *STBox, maxdd int) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.stbox_round(box._inner, C.int(maxdd)) - return &STBox{_inner: _cret} + 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) *STBox { +func STBOXShiftScaleTime(box *STBox, shift *Interval, duration *Interval) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.stbox_shift_scale_time(box._inner, shift._inner, duration._inner) - return &STBox{_inner: _cret} + 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) *STBox { +func StboxarrRound(boxarr *STBox, count int, maxdd int) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.stboxarr_round(boxarr._inner, C.int(count), C.int(maxdd)) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // STBOXSetSRID wraps MEOS C function stbox_set_srid. -func STBOXSetSRID(box *STBox, srid int32) *STBox { +func STBOXSetSRID(box *STBox, srid int32) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.stbox_set_srid(box._inner, C.int32_t(srid)) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // STBOXSRID wraps MEOS C function stbox_srid. -func STBOXSRID(box *STBox) int32 { +func STBOXSRID(box *STBox) (_r0 int32, _err error) { + C.meos_errno_reset() _cret := C.stbox_srid(box._inner) - return int32(_cret) + if _err = meosError(); _err != nil { + return + } + return int32(_cret), nil } // STBOXTransform wraps MEOS C function stbox_transform. -func STBOXTransform(box *STBox, srid int32) *STBox { +func STBOXTransform(box *STBox, srid int32) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.stbox_transform(box._inner, C.int32_t(srid)) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // STBOXTransformPipeline wraps MEOS C function stbox_transform_pipeline. -func STBOXTransformPipeline(box *STBox, pipelinestr string, srid int32, is_forward bool) *STBox { +func STBOXTransformPipeline(box *STBox, pipelinestr string, srid int32, is_forward bool) (_r0 *STBox, _err error) { _c_pipelinestr := C.CString(pipelinestr) defer C.free(unsafe.Pointer(_c_pipelinestr)) + C.meos_errno_reset() _cret := C.stbox_transform_pipeline(box._inner, _c_pipelinestr, C.int32_t(srid), C.bool(is_forward)) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // AdjacentSTBOXSTBOX wraps MEOS C function adjacent_stbox_stbox. -func AdjacentSTBOXSTBOX(box1 *STBox, box2 *STBox) bool { +func AdjacentSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_stbox_stbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedSTBOXSTBOX wraps MEOS C function contained_stbox_stbox. -func ContainedSTBOXSTBOX(box1 *STBox, box2 *STBox) bool { +func ContainedSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_stbox_stbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSTBOXSTBOX wraps MEOS C function contains_stbox_stbox. -func ContainsSTBOXSTBOX(box1 *STBox, box2 *STBox) bool { +func ContainsSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_stbox_stbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverlapsSTBOXSTBOX wraps MEOS C function overlaps_stbox_stbox. -func OverlapsSTBOXSTBOX(box1 *STBox, box2 *STBox) bool { +func OverlapsSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overlaps_stbox_stbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SameSTBOXSTBOX wraps MEOS C function same_stbox_stbox. -func SameSTBOXSTBOX(box1 *STBox, box2 *STBox) bool { +func SameSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.same_stbox_stbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AboveSTBOXSTBOX wraps MEOS C function above_stbox_stbox. -func AboveSTBOXSTBOX(box1 *STBox, box2 *STBox) bool { +func AboveSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.above_stbox_stbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterSTBOXSTBOX wraps MEOS C function after_stbox_stbox. -func AfterSTBOXSTBOX(box1 *STBox, box2 *STBox) bool { +func AfterSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_stbox_stbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BackSTBOXSTBOX wraps MEOS C function back_stbox_stbox. -func BackSTBOXSTBOX(box1 *STBox, box2 *STBox) bool { +func BackSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.back_stbox_stbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeSTBOXSTBOX wraps MEOS C function before_stbox_stbox. -func BeforeSTBOXSTBOX(box1 *STBox, box2 *STBox) bool { +func BeforeSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_stbox_stbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BelowSTBOXSTBOX wraps MEOS C function below_stbox_stbox. -func BelowSTBOXSTBOX(box1 *STBox, box2 *STBox) bool { +func BelowSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.below_stbox_stbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // FrontSTBOXSTBOX wraps MEOS C function front_stbox_stbox. -func FrontSTBOXSTBOX(box1 *STBox, box2 *STBox) bool { +func FrontSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.front_stbox_stbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftSTBOXSTBOX wraps MEOS C function left_stbox_stbox. -func LeftSTBOXSTBOX(box1 *STBox, box2 *STBox) bool { +func LeftSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_stbox_stbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OveraboveSTBOXSTBOX wraps MEOS C function overabove_stbox_stbox. -func OveraboveSTBOXSTBOX(box1 *STBox, box2 *STBox) bool { +func OveraboveSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overabove_stbox_stbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterSTBOXSTBOX wraps MEOS C function overafter_stbox_stbox. -func OverafterSTBOXSTBOX(box1 *STBox, box2 *STBox) bool { +func OverafterSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_stbox_stbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbackSTBOXSTBOX wraps MEOS C function overback_stbox_stbox. -func OverbackSTBOXSTBOX(box1 *STBox, box2 *STBox) bool { +func OverbackSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overback_stbox_stbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeSTBOXSTBOX wraps MEOS C function overbefore_stbox_stbox. -func OverbeforeSTBOXSTBOX(box1 *STBox, box2 *STBox) bool { +func OverbeforeSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_stbox_stbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbelowSTBOXSTBOX wraps MEOS C function overbelow_stbox_stbox. -func OverbelowSTBOXSTBOX(box1 *STBox, box2 *STBox) bool { +func OverbelowSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbelow_stbox_stbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverfrontSTBOXSTBOX wraps MEOS C function overfront_stbox_stbox. -func OverfrontSTBOXSTBOX(box1 *STBox, box2 *STBox) bool { +func OverfrontSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overfront_stbox_stbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftSTBOXSTBOX wraps MEOS C function overleft_stbox_stbox. -func OverleftSTBOXSTBOX(box1 *STBox, box2 *STBox) bool { +func OverleftSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_stbox_stbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightSTBOXSTBOX wraps MEOS C function overright_stbox_stbox. -func OverrightSTBOXSTBOX(box1 *STBox, box2 *STBox) bool { +func OverrightSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_stbox_stbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightSTBOXSTBOX wraps MEOS C function right_stbox_stbox. -func RightSTBOXSTBOX(box1 *STBox, box2 *STBox) bool { +func RightSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_stbox_stbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // UnionSTBOXSTBOX wraps MEOS C function union_stbox_stbox. -func UnionSTBOXSTBOX(box1 *STBox, box2 *STBox, strict bool) *STBox { +func UnionSTBOXSTBOX(box1 *STBox, box2 *STBox, strict bool) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.gunion_stbox_stbox(box1._inner, box2._inner, C.bool(strict)) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // IntersectionSTBOXSTBOX wraps MEOS C function intersection_stbox_stbox. -func IntersectionSTBOXSTBOX(box1 *STBox, box2 *STBox) *STBox { +func IntersectionSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.intersection_stbox_stbox(box1._inner, box2._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // STBOXCmp wraps MEOS C function stbox_cmp. -func STBOXCmp(box1 *STBox, box2 *STBox) int { +func STBOXCmp(box1 *STBox, box2 *STBox) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.stbox_cmp(box1._inner, box2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // STBOXEq wraps MEOS C function stbox_eq. -func STBOXEq(box1 *STBox, box2 *STBox) bool { +func STBOXEq(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.stbox_eq(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // STBOXGe wraps MEOS C function stbox_ge. -func STBOXGe(box1 *STBox, box2 *STBox) bool { +func STBOXGe(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.stbox_ge(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // STBOXGt wraps MEOS C function stbox_gt. -func STBOXGt(box1 *STBox, box2 *STBox) bool { +func STBOXGt(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.stbox_gt(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // STBOXLe wraps MEOS C function stbox_le. -func STBOXLe(box1 *STBox, box2 *STBox) bool { +func STBOXLe(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.stbox_le(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // STBOXLt wraps MEOS C function stbox_lt. -func STBOXLt(box1 *STBox, box2 *STBox) bool { +func STBOXLt(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.stbox_lt(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // STBOXNe wraps MEOS C function stbox_ne. -func STBOXNe(box1 *STBox, box2 *STBox) bool { +func STBOXNe(box1 *STBox, box2 *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.stbox_ne(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TspatialOut wraps MEOS C function tspatial_out. -func TspatialOut(temp *Temporal, maxdd int) string { +func TspatialOut(temp *Temporal, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.tspatial_out(temp._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TgeogpointFromMFJSON wraps MEOS C function tgeogpoint_from_mfjson. -func TgeogpointFromMFJSON(str string) *Temporal { +func TgeogpointFromMFJSON(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tgeogpoint_from_mfjson(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeogpointIn wraps MEOS C function tgeogpoint_in. -func TgeogpointIn(str string) *Temporal { +func TgeogpointIn(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tgeogpoint_in(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeographyFromMFJSON wraps MEOS C function tgeography_from_mfjson. -func TgeographyFromMFJSON(mfjson string) *Temporal { +func TgeographyFromMFJSON(mfjson string) (_r0 *Temporal, _err error) { _c_mfjson := C.CString(mfjson) defer C.free(unsafe.Pointer(_c_mfjson)) + C.meos_errno_reset() _cret := C.tgeography_from_mfjson(_c_mfjson) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeographyIn wraps MEOS C function tgeography_in. -func TgeographyIn(str string) *Temporal { +func TgeographyIn(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tgeography_in(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeometryFromMFJSON wraps MEOS C function tgeometry_from_mfjson. -func TgeometryFromMFJSON(str string) *Temporal { +func TgeometryFromMFJSON(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tgeometry_from_mfjson(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeometryIn wraps MEOS C function tgeometry_in. -func TgeometryIn(str string) *Temporal { +func TgeometryIn(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tgeometry_in(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeompointFromMFJSON wraps MEOS C function tgeompoint_from_mfjson. -func TgeompointFromMFJSON(str string) *Temporal { +func TgeompointFromMFJSON(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tgeompoint_from_mfjson(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeompointIn wraps MEOS C function tgeompoint_in. -func TgeompointIn(str string) *Temporal { +func TgeompointIn(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tgeompoint_in(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TspatialAsEWKT wraps MEOS C function tspatial_as_ewkt. -func TspatialAsEWKT(temp *Temporal, maxdd int) string { +func TspatialAsEWKT(temp *Temporal, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.tspatial_as_ewkt(temp._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TspatialAsText wraps MEOS C function tspatial_as_text. -func TspatialAsText(temp *Temporal, maxdd int) string { +func TspatialAsText(temp *Temporal, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.tspatial_as_text(temp._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TgeoFromBaseTemp wraps MEOS C function tgeo_from_base_temp. -func TgeoFromBaseTemp(gs *Geom, temp *Temporal) *Temporal { +func TgeoFromBaseTemp(gs *Geom, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeo_from_base_temp(gs._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeoinstMake wraps MEOS C function tgeoinst_make. -func TgeoinstMake(gs *Geom, t int64) *TInstant { +func TgeoinstMake(gs *Geom, t int64) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tgeoinst_make(gs._inner, C.TimestampTz(t)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TgeoseqFromBaseTstzset wraps MEOS C function tgeoseq_from_base_tstzset. -func TgeoseqFromBaseTstzset(gs *Geom, s *Set) *TSequence { +func TgeoseqFromBaseTstzset(gs *Geom, s *Set) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tgeoseq_from_base_tstzset(gs._inner, s._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TgeoseqFromBaseTstzspan wraps MEOS C function tgeoseq_from_base_tstzspan. -func TgeoseqFromBaseTstzspan(gs *Geom, s *Span, interp Interpolation) *TSequence { +func TgeoseqFromBaseTstzspan(gs *Geom, s *Span, interp Interpolation) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tgeoseq_from_base_tstzspan(gs._inner, s._inner, C.interpType(interp)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TgeoseqsetFromBaseTstzspanset wraps MEOS C function tgeoseqset_from_base_tstzspanset. -func TgeoseqsetFromBaseTstzspanset(gs *Geom, ss *SpanSet, interp Interpolation) *TSequenceSet { +func TgeoseqsetFromBaseTstzspanset(gs *Geom, ss *SpanSet, interp Interpolation) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tgeoseqset_from_base_tstzspanset(gs._inner, ss._inner, C.interpType(interp)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TpointFromBaseTemp wraps MEOS C function tpoint_from_base_temp. -func TpointFromBaseTemp(gs *Geom, temp *Temporal) *Temporal { +func TpointFromBaseTemp(gs *Geom, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpoint_from_base_temp(gs._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpointinstMake wraps MEOS C function tpointinst_make. -func TpointinstMake(gs *Geom, t int64) *TInstant { +func TpointinstMake(gs *Geom, t int64) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tpointinst_make(gs._inner, C.TimestampTz(t)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TpointseqFromBaseTstzset wraps MEOS C function tpointseq_from_base_tstzset. -func TpointseqFromBaseTstzset(gs *Geom, s *Set) *TSequence { +func TpointseqFromBaseTstzset(gs *Geom, s *Set) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tpointseq_from_base_tstzset(gs._inner, s._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TpointseqFromBaseTstzspan wraps MEOS C function tpointseq_from_base_tstzspan. -func TpointseqFromBaseTstzspan(gs *Geom, s *Span, interp Interpolation) *TSequence { +func TpointseqFromBaseTstzspan(gs *Geom, s *Span, interp Interpolation) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tpointseq_from_base_tstzspan(gs._inner, s._inner, C.interpType(interp)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TpointseqMakeCoords wraps MEOS C function tpointseq_make_coords. -func TpointseqMakeCoords(xcoords unsafe.Pointer, ycoords unsafe.Pointer, zcoords unsafe.Pointer, times unsafe.Pointer, count int, srid int32, geodetic bool, lower_inc bool, upper_inc bool, interp Interpolation, normalize bool) *TSequence { +func TpointseqMakeCoords(xcoords unsafe.Pointer, ycoords unsafe.Pointer, zcoords unsafe.Pointer, times unsafe.Pointer, count int, srid int32, geodetic bool, lower_inc bool, upper_inc bool, interp Interpolation, normalize bool) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tpointseq_make_coords((*C.double)(unsafe.Pointer(xcoords)), (*C.double)(unsafe.Pointer(ycoords)), (*C.double)(unsafe.Pointer(zcoords)), (*C.TimestampTz)(unsafe.Pointer(times)), C.int(count), C.int32_t(srid), C.bool(geodetic), C.bool(lower_inc), C.bool(upper_inc), C.interpType(interp), C.bool(normalize)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TpointseqsetFromBaseTstzspanset wraps MEOS C function tpointseqset_from_base_tstzspanset. -func TpointseqsetFromBaseTstzspanset(gs *Geom, ss *SpanSet, interp Interpolation) *TSequenceSet { +func TpointseqsetFromBaseTstzspanset(gs *Geom, ss *SpanSet, interp Interpolation) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tpointseqset_from_base_tstzspanset(gs._inner, ss._inner, C.interpType(interp)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // Box3dToSTBOX wraps MEOS C function box3d_to_stbox. -func Box3dToSTBOX(box *Box3D) *STBox { +func Box3dToSTBOX(box *Box3D) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.box3d_to_stbox(box._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // GboxToSTBOX wraps MEOS C function gbox_to_stbox. -func GboxToSTBOX(box *GBox) *STBox { +func GboxToSTBOX(box *GBox) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.gbox_to_stbox(box._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // GeomeasToTpoint wraps MEOS C function geomeas_to_tpoint. -func GeomeasToTpoint(gs *Geom) *Temporal { +func GeomeasToTpoint(gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.geomeas_to_tpoint(gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeogpointToTgeography wraps MEOS C function tgeogpoint_to_tgeography. -func TgeogpointToTgeography(temp *Temporal) *Temporal { +func TgeogpointToTgeography(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeogpoint_to_tgeography(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeographyToTgeogpoint wraps MEOS C function tgeography_to_tgeogpoint. -func TgeographyToTgeogpoint(temp *Temporal) *Temporal { +func TgeographyToTgeogpoint(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeography_to_tgeogpoint(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeographyToTgeometry wraps MEOS C function tgeography_to_tgeometry. -func TgeographyToTgeometry(temp *Temporal) *Temporal { +func TgeographyToTgeometry(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeography_to_tgeometry(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeometryToTgeography wraps MEOS C function tgeometry_to_tgeography. -func TgeometryToTgeography(temp *Temporal) *Temporal { +func TgeometryToTgeography(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeometry_to_tgeography(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeometryToTgeompoint wraps MEOS C function tgeometry_to_tgeompoint. -func TgeometryToTgeompoint(temp *Temporal) *Temporal { +func TgeometryToTgeompoint(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeometry_to_tgeompoint(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeompointToTgeometry wraps MEOS C function tgeompoint_to_tgeometry. -func TgeompointToTgeometry(temp *Temporal) *Temporal { +func TgeompointToTgeometry(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeompoint_to_tgeometry(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } @@ -1712,1556 +2600,2440 @@ func TgeompointToTgeometry(temp *Temporal) *Temporal { // TpointTfloatToGeomeas wraps MEOS C function tpoint_tfloat_to_geomeas. -func TpointTfloatToGeomeas(tpoint *Temporal, measure *Temporal, segmentize bool) (bool, *Geom) { +func TpointTfloatToGeomeas(tpoint *Temporal, measure *Temporal, segmentize bool) (_r0 bool, _r1 *Geom, _err error) { var _out_result *C.GSERIALIZED + C.meos_errno_reset() _cret := C.tpoint_tfloat_to_geomeas(tpoint._inner, measure._inner, C.bool(segmentize), &_out_result) - return bool(_cret), &Geom{_inner: _out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Geom{_inner: _out_result}, nil } // TspatialToSTBOX wraps MEOS C function tspatial_to_stbox. -func TspatialToSTBOX(temp *Temporal) *STBox { +func TspatialToSTBOX(temp *Temporal) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.tspatial_to_stbox(temp._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // BearingPointPoint wraps MEOS C function bearing_point_point. -func BearingPointPoint(gs1 *Geom, gs2 *Geom) (bool, float64) { +func BearingPointPoint(gs1 *Geom, gs2 *Geom) (_r0 bool, _r1 float64, _err error) { var _out_result C.double + C.meos_errno_reset() _cret := C.bearing_point_point(gs1._inner, gs2._inner, &_out_result) - return bool(_cret), float64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), float64(_out_result), nil } // BearingTpointPoint wraps MEOS C function bearing_tpoint_point. -func BearingTpointPoint(temp *Temporal, gs *Geom, invert bool) *Temporal { +func BearingTpointPoint(temp *Temporal, gs *Geom, invert bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.bearing_tpoint_point(temp._inner, gs._inner, C.bool(invert)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // BearingTpointTpoint wraps MEOS C function bearing_tpoint_tpoint. -func BearingTpointTpoint(temp1 *Temporal, temp2 *Temporal) *Temporal { +func BearingTpointTpoint(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.bearing_tpoint_tpoint(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeoCentroid wraps MEOS C function tgeo_centroid. -func TgeoCentroid(temp *Temporal) *Temporal { +func TgeoCentroid(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeo_centroid(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeoConvexHull wraps MEOS C function tgeo_convex_hull. -func TgeoConvexHull(temp *Temporal) *Geom { +func TgeoConvexHull(temp *Temporal) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.tgeo_convex_hull(temp._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // TgeoEndValue wraps MEOS C function tgeo_end_value. -func TgeoEndValue(temp *Temporal) *Geom { +func TgeoEndValue(temp *Temporal) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.tgeo_end_value(temp._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // TgeoStartValue wraps MEOS C function tgeo_start_value. -func TgeoStartValue(temp *Temporal) *Geom { +func TgeoStartValue(temp *Temporal) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.tgeo_start_value(temp._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // TgeoTraversedArea wraps MEOS C function tgeo_traversed_area. -func TgeoTraversedArea(temp *Temporal, unary_union bool) *Geom { +func TgeoTraversedArea(temp *Temporal, unary_union bool) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.tgeo_traversed_area(temp._inner, C.bool(unary_union)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // TgeoValueAtTimestamptz wraps MEOS C function tgeo_value_at_timestamptz. -func TgeoValueAtTimestamptz(temp *Temporal, t int64, strict bool) (bool, *Geom) { +func TgeoValueAtTimestamptz(temp *Temporal, t int64, strict bool) (_r0 bool, _r1 *Geom, _err error) { var _out_result *C.GSERIALIZED + C.meos_errno_reset() _cret := C.tgeo_value_at_timestamptz(temp._inner, C.TimestampTz(t), C.bool(strict), &_out_result) - return bool(_cret), &Geom{_inner: _out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Geom{_inner: _out_result}, nil } // TgeoValueN wraps MEOS C function tgeo_value_n. -func TgeoValueN(temp *Temporal, n int) (bool, *Geom) { +func TgeoValueN(temp *Temporal, n int) (_r0 bool, _r1 *Geom, _err error) { var _out_result *C.GSERIALIZED + C.meos_errno_reset() _cret := C.tgeo_value_n(temp._inner, C.int(n), &_out_result) - return bool(_cret), &Geom{_inner: _out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Geom{_inner: _out_result}, nil } // TgeoValues wraps MEOS C function tgeo_values. -func TgeoValues(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TgeoValues(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tgeo_values(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TpointAngularDifference wraps MEOS C function tpoint_angular_difference. -func TpointAngularDifference(temp *Temporal) *Temporal { +func TpointAngularDifference(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpoint_angular_difference(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpointAzimuth wraps MEOS C function tpoint_azimuth. -func TpointAzimuth(temp *Temporal) *Temporal { +func TpointAzimuth(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpoint_azimuth(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpointCumulativeLength wraps MEOS C function tpoint_cumulative_length. -func TpointCumulativeLength(temp *Temporal) *Temporal { +func TpointCumulativeLength(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpoint_cumulative_length(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpointDirection wraps MEOS C function tpoint_direction. -func TpointDirection(temp *Temporal) (bool, float64) { +func TpointDirection(temp *Temporal) (_r0 bool, _r1 float64, _err error) { var _out_result C.double + C.meos_errno_reset() _cret := C.tpoint_direction(temp._inner, &_out_result) - return bool(_cret), float64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), float64(_out_result), nil } // TpointGetX wraps MEOS C function tpoint_get_x. -func TpointGetX(temp *Temporal) *Temporal { +func TpointGetX(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpoint_get_x(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpointGetY wraps MEOS C function tpoint_get_y. -func TpointGetY(temp *Temporal) *Temporal { +func TpointGetY(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpoint_get_y(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpointGetZ wraps MEOS C function tpoint_get_z. -func TpointGetZ(temp *Temporal) *Temporal { +func TpointGetZ(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpoint_get_z(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpointIsSimple wraps MEOS C function tpoint_is_simple. -func TpointIsSimple(temp *Temporal) bool { +func TpointIsSimple(temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tpoint_is_simple(temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TpointLength wraps MEOS C function tpoint_length. -func TpointLength(temp *Temporal) float64 { +func TpointLength(temp *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.tpoint_length(temp._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TpointSpeed wraps MEOS C function tpoint_speed. -func TpointSpeed(temp *Temporal) *Temporal { +func TpointSpeed(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpoint_speed(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpointTrajectory wraps MEOS C function tpoint_trajectory. -func TpointTrajectory(temp *Temporal, unary_union bool) *Geom { +func TpointTrajectory(temp *Temporal, unary_union bool) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.tpoint_trajectory(temp._inner, C.bool(unary_union)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // TpointTwcentroid wraps MEOS C function tpoint_twcentroid. -func TpointTwcentroid(temp *Temporal) *Geom { +func TpointTwcentroid(temp *Temporal) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.tpoint_twcentroid(temp._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // TgeoAffine wraps MEOS C function tgeo_affine. -func TgeoAffine(temp *Temporal, a *AFFINE) *Temporal { +func TgeoAffine(temp *Temporal, a *AFFINE) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeo_affine(temp._inner, a._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeoScale wraps MEOS C function tgeo_scale. -func TgeoScale(temp *Temporal, scale *Geom, sorigin *Geom) *Temporal { +func TgeoScale(temp *Temporal, scale *Geom, sorigin *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeo_scale(temp._inner, scale._inner, sorigin._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpointMakeSimple wraps MEOS C function tpoint_make_simple. -func TpointMakeSimple(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TpointMakeSimple(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tpoint_make_simple(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TspatialSRID wraps MEOS C function tspatial_srid. -func TspatialSRID(temp *Temporal) int32 { +func TspatialSRID(temp *Temporal) (_r0 int32, _err error) { + C.meos_errno_reset() _cret := C.tspatial_srid(temp._inner) - return int32(_cret) + if _err = meosError(); _err != nil { + return + } + return int32(_cret), nil } // TspatialSetSRID wraps MEOS C function tspatial_set_srid. -func TspatialSetSRID(temp *Temporal, srid int32) *Temporal { +func TspatialSetSRID(temp *Temporal, srid int32) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tspatial_set_srid(temp._inner, C.int32_t(srid)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TspatialTransform wraps MEOS C function tspatial_transform. -func TspatialTransform(temp *Temporal, srid int32) *Temporal { +func TspatialTransform(temp *Temporal, srid int32) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tspatial_transform(temp._inner, C.int32_t(srid)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TspatialTransformPipeline wraps MEOS C function tspatial_transform_pipeline. -func TspatialTransformPipeline(temp *Temporal, pipelinestr string, srid int32, is_forward bool) *Temporal { +func TspatialTransformPipeline(temp *Temporal, pipelinestr string, srid int32, is_forward bool) (_r0 *Temporal, _err error) { _c_pipelinestr := C.CString(pipelinestr) defer C.free(unsafe.Pointer(_c_pipelinestr)) + C.meos_errno_reset() _cret := C.tspatial_transform_pipeline(temp._inner, _c_pipelinestr, C.int32_t(srid), C.bool(is_forward)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeoAtGeom wraps MEOS C function tgeo_at_geom. -func TgeoAtGeom(temp *Temporal, gs *Geom) *Temporal { +func TgeoAtGeom(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeo_at_geom(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeoAtSTBOX wraps MEOS C function tgeo_at_stbox. -func TgeoAtSTBOX(temp *Temporal, box *STBox, border_inc bool) *Temporal { +func TgeoAtSTBOX(temp *Temporal, box *STBox, border_inc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeo_at_stbox(temp._inner, box._inner, C.bool(border_inc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeoAtValue wraps MEOS C function tgeo_at_value. -func TgeoAtValue(temp *Temporal, gs *Geom) *Temporal { +func TgeoAtValue(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeo_at_value(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeoMinusGeom wraps MEOS C function tgeo_minus_geom. -func TgeoMinusGeom(temp *Temporal, gs *Geom) *Temporal { +func TgeoMinusGeom(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeo_minus_geom(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeoMinusSTBOX wraps MEOS C function tgeo_minus_stbox. -func TgeoMinusSTBOX(temp *Temporal, box *STBox, border_inc bool) *Temporal { +func TgeoMinusSTBOX(temp *Temporal, box *STBox, border_inc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeo_minus_stbox(temp._inner, box._inner, C.bool(border_inc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeoMinusValue wraps MEOS C function tgeo_minus_value. -func TgeoMinusValue(temp *Temporal, gs *Geom) *Temporal { +func TgeoMinusValue(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeo_minus_value(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpointAtElevation wraps MEOS C function tpoint_at_elevation. -func TpointAtElevation(temp *Temporal, s *Span) *Temporal { +func TpointAtElevation(temp *Temporal, s *Span) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpoint_at_elevation(temp._inner, s._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpointAtGeom wraps MEOS C function tpoint_at_geom. -func TpointAtGeom(temp *Temporal, gs *Geom) *Temporal { +func TpointAtGeom(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpoint_at_geom(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpointAtValue wraps MEOS C function tpoint_at_value. -func TpointAtValue(temp *Temporal, gs *Geom) *Temporal { +func TpointAtValue(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpoint_at_value(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpointMinusElevation wraps MEOS C function tpoint_minus_elevation. -func TpointMinusElevation(temp *Temporal, s *Span) *Temporal { +func TpointMinusElevation(temp *Temporal, s *Span) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpoint_minus_elevation(temp._inner, s._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpointMinusGeom wraps MEOS C function tpoint_minus_geom. -func TpointMinusGeom(temp *Temporal, gs *Geom) *Temporal { +func TpointMinusGeom(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpoint_minus_geom(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpointMinusValue wraps MEOS C function tpoint_minus_value. -func TpointMinusValue(temp *Temporal, gs *Geom) *Temporal { +func TpointMinusValue(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpoint_minus_value(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // AlwaysEqGeoTgeo wraps MEOS C function always_eq_geo_tgeo. -func AlwaysEqGeoTgeo(gs *Geom, temp *Temporal) int { +func AlwaysEqGeoTgeo(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_geo_tgeo(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTgeoGeo wraps MEOS C function always_eq_tgeo_geo. -func AlwaysEqTgeoGeo(temp *Temporal, gs *Geom) int { +func AlwaysEqTgeoGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_tgeo_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTgeoTgeo wraps MEOS C function always_eq_tgeo_tgeo. -func AlwaysEqTgeoTgeo(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysEqTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_tgeo_tgeo(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeGeoTgeo wraps MEOS C function always_ne_geo_tgeo. -func AlwaysNeGeoTgeo(gs *Geom, temp *Temporal) int { +func AlwaysNeGeoTgeo(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_geo_tgeo(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTgeoGeo wraps MEOS C function always_ne_tgeo_geo. -func AlwaysNeTgeoGeo(temp *Temporal, gs *Geom) int { +func AlwaysNeTgeoGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_tgeo_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTgeoTgeo wraps MEOS C function always_ne_tgeo_tgeo. -func AlwaysNeTgeoTgeo(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysNeTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_tgeo_tgeo(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqGeoTgeo wraps MEOS C function ever_eq_geo_tgeo. -func EverEqGeoTgeo(gs *Geom, temp *Temporal) int { +func EverEqGeoTgeo(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_geo_tgeo(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTgeoGeo wraps MEOS C function ever_eq_tgeo_geo. -func EverEqTgeoGeo(temp *Temporal, gs *Geom) int { +func EverEqTgeoGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_tgeo_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTgeoTgeo wraps MEOS C function ever_eq_tgeo_tgeo. -func EverEqTgeoTgeo(temp1 *Temporal, temp2 *Temporal) int { +func EverEqTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_tgeo_tgeo(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeGeoTgeo wraps MEOS C function ever_ne_geo_tgeo. -func EverNeGeoTgeo(gs *Geom, temp *Temporal) int { +func EverNeGeoTgeo(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_geo_tgeo(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTgeoGeo wraps MEOS C function ever_ne_tgeo_geo. -func EverNeTgeoGeo(temp *Temporal, gs *Geom) int { +func EverNeTgeoGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_tgeo_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTgeoTgeo wraps MEOS C function ever_ne_tgeo_tgeo. -func EverNeTgeoTgeo(temp1 *Temporal, temp2 *Temporal) int { +func EverNeTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_tgeo_tgeo(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TeqGeoTgeo wraps MEOS C function teq_geo_tgeo. -func TeqGeoTgeo(gs *Geom, temp *Temporal) *Temporal { +func TeqGeoTgeo(gs *Geom, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_geo_tgeo(gs._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TeqTgeoGeo wraps MEOS C function teq_tgeo_geo. -func TeqTgeoGeo(temp *Temporal, gs *Geom) *Temporal { +func TeqTgeoGeo(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_tgeo_geo(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneGeoTgeo wraps MEOS C function tne_geo_tgeo. -func TneGeoTgeo(gs *Geom, temp *Temporal) *Temporal { +func TneGeoTgeo(gs *Geom, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_geo_tgeo(gs._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneTgeoGeo wraps MEOS C function tne_tgeo_geo. -func TneTgeoGeo(temp *Temporal, gs *Geom) *Temporal { +func TneTgeoGeo(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_tgeo_geo(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeoStboxes wraps MEOS C function tgeo_stboxes. -func TgeoStboxes(temp *Temporal, count unsafe.Pointer) *STBox { +func TgeoStboxes(temp *Temporal, count unsafe.Pointer) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.tgeo_stboxes(temp._inner, (*C.int)(unsafe.Pointer(count))) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // TgeoSpaceBoxes wraps MEOS C function tgeo_space_boxes. -func TgeoSpaceBoxes(temp *Temporal, xsize float64, ysize float64, zsize float64, sorigin *Geom, bitmatrix bool, border_inc bool, count unsafe.Pointer) *STBox { +func TgeoSpaceBoxes(temp *Temporal, xsize float64, ysize float64, zsize float64, sorigin *Geom, bitmatrix bool, border_inc bool, count unsafe.Pointer) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.tgeo_space_boxes(temp._inner, C.double(xsize), C.double(ysize), C.double(zsize), sorigin._inner, C.bool(bitmatrix), C.bool(border_inc), (*C.int)(unsafe.Pointer(count))) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // TgeoSpaceTimeBoxes wraps MEOS C function tgeo_space_time_boxes. -func TgeoSpaceTimeBoxes(temp *Temporal, xsize float64, ysize float64, zsize float64, duration *Interval, sorigin *Geom, torigin int64, bitmatrix bool, border_inc bool, count unsafe.Pointer) *STBox { +func TgeoSpaceTimeBoxes(temp *Temporal, xsize float64, ysize float64, zsize float64, duration *Interval, sorigin *Geom, torigin int64, bitmatrix bool, border_inc bool, count unsafe.Pointer) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.tgeo_space_time_boxes(temp._inner, C.double(xsize), C.double(ysize), C.double(zsize), duration._inner, sorigin._inner, C.TimestampTz(torigin), C.bool(bitmatrix), C.bool(border_inc), (*C.int)(unsafe.Pointer(count))) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // TgeoSplitEachNStboxes wraps MEOS C function tgeo_split_each_n_stboxes. -func TgeoSplitEachNStboxes(temp *Temporal, elem_count int, count unsafe.Pointer) *STBox { +func TgeoSplitEachNStboxes(temp *Temporal, elem_count int, count unsafe.Pointer) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.tgeo_split_each_n_stboxes(temp._inner, C.int(elem_count), (*C.int)(unsafe.Pointer(count))) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // TgeoSplitNStboxes wraps MEOS C function tgeo_split_n_stboxes. -func TgeoSplitNStboxes(temp *Temporal, box_count int, count unsafe.Pointer) *STBox { +func TgeoSplitNStboxes(temp *Temporal, box_count int, count unsafe.Pointer) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.tgeo_split_n_stboxes(temp._inner, C.int(box_count), (*C.int)(unsafe.Pointer(count))) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // AdjacentSTBOXTspatial wraps MEOS C function adjacent_stbox_tspatial. -func AdjacentSTBOXTspatial(box *STBox, temp *Temporal) bool { +func AdjacentSTBOXTspatial(box *STBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_stbox_tspatial(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentTspatialSTBOX wraps MEOS C function adjacent_tspatial_stbox. -func AdjacentTspatialSTBOX(temp *Temporal, box *STBox) bool { +func AdjacentTspatialSTBOX(temp *Temporal, box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_tspatial_stbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentTspatialTspatial wraps MEOS C function adjacent_tspatial_tspatial. -func AdjacentTspatialTspatial(temp1 *Temporal, temp2 *Temporal) bool { +func AdjacentTspatialTspatial(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_tspatial_tspatial(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedSTBOXTspatial wraps MEOS C function contained_stbox_tspatial. -func ContainedSTBOXTspatial(box *STBox, temp *Temporal) bool { +func ContainedSTBOXTspatial(box *STBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_stbox_tspatial(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedTspatialSTBOX wraps MEOS C function contained_tspatial_stbox. -func ContainedTspatialSTBOX(temp *Temporal, box *STBox) bool { +func ContainedTspatialSTBOX(temp *Temporal, box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_tspatial_stbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedTspatialTspatial wraps MEOS C function contained_tspatial_tspatial. -func ContainedTspatialTspatial(temp1 *Temporal, temp2 *Temporal) bool { +func ContainedTspatialTspatial(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_tspatial_tspatial(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSTBOXTspatial wraps MEOS C function contains_stbox_tspatial. -func ContainsSTBOXTspatial(box *STBox, temp *Temporal) bool { +func ContainsSTBOXTspatial(box *STBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_stbox_tspatial(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsTspatialSTBOX wraps MEOS C function contains_tspatial_stbox. -func ContainsTspatialSTBOX(temp *Temporal, box *STBox) bool { +func ContainsTspatialSTBOX(temp *Temporal, box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_tspatial_stbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsTspatialTspatial wraps MEOS C function contains_tspatial_tspatial. -func ContainsTspatialTspatial(temp1 *Temporal, temp2 *Temporal) bool { +func ContainsTspatialTspatial(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_tspatial_tspatial(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverlapsSTBOXTspatial wraps MEOS C function overlaps_stbox_tspatial. -func OverlapsSTBOXTspatial(box *STBox, temp *Temporal) bool { +func OverlapsSTBOXTspatial(box *STBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overlaps_stbox_tspatial(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverlapsTspatialSTBOX wraps MEOS C function overlaps_tspatial_stbox. -func OverlapsTspatialSTBOX(temp *Temporal, box *STBox) bool { +func OverlapsTspatialSTBOX(temp *Temporal, box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overlaps_tspatial_stbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverlapsTspatialTspatial wraps MEOS C function overlaps_tspatial_tspatial. -func OverlapsTspatialTspatial(temp1 *Temporal, temp2 *Temporal) bool { +func OverlapsTspatialTspatial(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overlaps_tspatial_tspatial(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SameSTBOXTspatial wraps MEOS C function same_stbox_tspatial. -func SameSTBOXTspatial(box *STBox, temp *Temporal) bool { +func SameSTBOXTspatial(box *STBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.same_stbox_tspatial(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SameTspatialSTBOX wraps MEOS C function same_tspatial_stbox. -func SameTspatialSTBOX(temp *Temporal, box *STBox) bool { +func SameTspatialSTBOX(temp *Temporal, box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.same_tspatial_stbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SameTspatialTspatial wraps MEOS C function same_tspatial_tspatial. -func SameTspatialTspatial(temp1 *Temporal, temp2 *Temporal) bool { +func SameTspatialTspatial(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.same_tspatial_tspatial(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AboveSTBOXTspatial wraps MEOS C function above_stbox_tspatial. -func AboveSTBOXTspatial(box *STBox, temp *Temporal) bool { +func AboveSTBOXTspatial(box *STBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.above_stbox_tspatial(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AboveTspatialSTBOX wraps MEOS C function above_tspatial_stbox. -func AboveTspatialSTBOX(temp *Temporal, box *STBox) bool { +func AboveTspatialSTBOX(temp *Temporal, box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.above_tspatial_stbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AboveTspatialTspatial wraps MEOS C function above_tspatial_tspatial. -func AboveTspatialTspatial(temp1 *Temporal, temp2 *Temporal) bool { +func AboveTspatialTspatial(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.above_tspatial_tspatial(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterSTBOXTspatial wraps MEOS C function after_stbox_tspatial. -func AfterSTBOXTspatial(box *STBox, temp *Temporal) bool { +func AfterSTBOXTspatial(box *STBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_stbox_tspatial(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterTspatialSTBOX wraps MEOS C function after_tspatial_stbox. -func AfterTspatialSTBOX(temp *Temporal, box *STBox) bool { +func AfterTspatialSTBOX(temp *Temporal, box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_tspatial_stbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterTspatialTspatial wraps MEOS C function after_tspatial_tspatial. -func AfterTspatialTspatial(temp1 *Temporal, temp2 *Temporal) bool { +func AfterTspatialTspatial(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_tspatial_tspatial(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BackSTBOXTspatial wraps MEOS C function back_stbox_tspatial. -func BackSTBOXTspatial(box *STBox, temp *Temporal) bool { +func BackSTBOXTspatial(box *STBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.back_stbox_tspatial(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BackTspatialSTBOX wraps MEOS C function back_tspatial_stbox. -func BackTspatialSTBOX(temp *Temporal, box *STBox) bool { +func BackTspatialSTBOX(temp *Temporal, box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.back_tspatial_stbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BackTspatialTspatial wraps MEOS C function back_tspatial_tspatial. -func BackTspatialTspatial(temp1 *Temporal, temp2 *Temporal) bool { +func BackTspatialTspatial(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.back_tspatial_tspatial(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeSTBOXTspatial wraps MEOS C function before_stbox_tspatial. -func BeforeSTBOXTspatial(box *STBox, temp *Temporal) bool { +func BeforeSTBOXTspatial(box *STBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_stbox_tspatial(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeTspatialSTBOX wraps MEOS C function before_tspatial_stbox. -func BeforeTspatialSTBOX(temp *Temporal, box *STBox) bool { +func BeforeTspatialSTBOX(temp *Temporal, box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_tspatial_stbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeTspatialTspatial wraps MEOS C function before_tspatial_tspatial. -func BeforeTspatialTspatial(temp1 *Temporal, temp2 *Temporal) bool { +func BeforeTspatialTspatial(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_tspatial_tspatial(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BelowSTBOXTspatial wraps MEOS C function below_stbox_tspatial. -func BelowSTBOXTspatial(box *STBox, temp *Temporal) bool { +func BelowSTBOXTspatial(box *STBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.below_stbox_tspatial(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BelowTspatialSTBOX wraps MEOS C function below_tspatial_stbox. -func BelowTspatialSTBOX(temp *Temporal, box *STBox) bool { +func BelowTspatialSTBOX(temp *Temporal, box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.below_tspatial_stbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BelowTspatialTspatial wraps MEOS C function below_tspatial_tspatial. -func BelowTspatialTspatial(temp1 *Temporal, temp2 *Temporal) bool { +func BelowTspatialTspatial(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.below_tspatial_tspatial(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // FrontSTBOXTspatial wraps MEOS C function front_stbox_tspatial. -func FrontSTBOXTspatial(box *STBox, temp *Temporal) bool { +func FrontSTBOXTspatial(box *STBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.front_stbox_tspatial(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // FrontTspatialSTBOX wraps MEOS C function front_tspatial_stbox. -func FrontTspatialSTBOX(temp *Temporal, box *STBox) bool { +func FrontTspatialSTBOX(temp *Temporal, box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.front_tspatial_stbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // FrontTspatialTspatial wraps MEOS C function front_tspatial_tspatial. -func FrontTspatialTspatial(temp1 *Temporal, temp2 *Temporal) bool { +func FrontTspatialTspatial(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.front_tspatial_tspatial(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftSTBOXTspatial wraps MEOS C function left_stbox_tspatial. -func LeftSTBOXTspatial(box *STBox, temp *Temporal) bool { +func LeftSTBOXTspatial(box *STBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_stbox_tspatial(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftTspatialSTBOX wraps MEOS C function left_tspatial_stbox. -func LeftTspatialSTBOX(temp *Temporal, box *STBox) bool { +func LeftTspatialSTBOX(temp *Temporal, box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_tspatial_stbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftTspatialTspatial wraps MEOS C function left_tspatial_tspatial. -func LeftTspatialTspatial(temp1 *Temporal, temp2 *Temporal) bool { +func LeftTspatialTspatial(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_tspatial_tspatial(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OveraboveSTBOXTspatial wraps MEOS C function overabove_stbox_tspatial. -func OveraboveSTBOXTspatial(box *STBox, temp *Temporal) bool { +func OveraboveSTBOXTspatial(box *STBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overabove_stbox_tspatial(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OveraboveTspatialSTBOX wraps MEOS C function overabove_tspatial_stbox. -func OveraboveTspatialSTBOX(temp *Temporal, box *STBox) bool { +func OveraboveTspatialSTBOX(temp *Temporal, box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overabove_tspatial_stbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OveraboveTspatialTspatial wraps MEOS C function overabove_tspatial_tspatial. -func OveraboveTspatialTspatial(temp1 *Temporal, temp2 *Temporal) bool { +func OveraboveTspatialTspatial(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overabove_tspatial_tspatial(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterSTBOXTspatial wraps MEOS C function overafter_stbox_tspatial. -func OverafterSTBOXTspatial(box *STBox, temp *Temporal) bool { +func OverafterSTBOXTspatial(box *STBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_stbox_tspatial(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterTspatialSTBOX wraps MEOS C function overafter_tspatial_stbox. -func OverafterTspatialSTBOX(temp *Temporal, box *STBox) bool { +func OverafterTspatialSTBOX(temp *Temporal, box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_tspatial_stbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterTspatialTspatial wraps MEOS C function overafter_tspatial_tspatial. -func OverafterTspatialTspatial(temp1 *Temporal, temp2 *Temporal) bool { +func OverafterTspatialTspatial(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_tspatial_tspatial(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbackSTBOXTspatial wraps MEOS C function overback_stbox_tspatial. -func OverbackSTBOXTspatial(box *STBox, temp *Temporal) bool { +func OverbackSTBOXTspatial(box *STBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overback_stbox_tspatial(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbackTspatialSTBOX wraps MEOS C function overback_tspatial_stbox. -func OverbackTspatialSTBOX(temp *Temporal, box *STBox) bool { +func OverbackTspatialSTBOX(temp *Temporal, box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overback_tspatial_stbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbackTspatialTspatial wraps MEOS C function overback_tspatial_tspatial. -func OverbackTspatialTspatial(temp1 *Temporal, temp2 *Temporal) bool { +func OverbackTspatialTspatial(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overback_tspatial_tspatial(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeSTBOXTspatial wraps MEOS C function overbefore_stbox_tspatial. -func OverbeforeSTBOXTspatial(box *STBox, temp *Temporal) bool { +func OverbeforeSTBOXTspatial(box *STBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_stbox_tspatial(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeTspatialSTBOX wraps MEOS C function overbefore_tspatial_stbox. -func OverbeforeTspatialSTBOX(temp *Temporal, box *STBox) bool { +func OverbeforeTspatialSTBOX(temp *Temporal, box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_tspatial_stbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeTspatialTspatial wraps MEOS C function overbefore_tspatial_tspatial. -func OverbeforeTspatialTspatial(temp1 *Temporal, temp2 *Temporal) bool { +func OverbeforeTspatialTspatial(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_tspatial_tspatial(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbelowSTBOXTspatial wraps MEOS C function overbelow_stbox_tspatial. -func OverbelowSTBOXTspatial(box *STBox, temp *Temporal) bool { +func OverbelowSTBOXTspatial(box *STBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbelow_stbox_tspatial(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbelowTspatialSTBOX wraps MEOS C function overbelow_tspatial_stbox. -func OverbelowTspatialSTBOX(temp *Temporal, box *STBox) bool { +func OverbelowTspatialSTBOX(temp *Temporal, box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbelow_tspatial_stbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbelowTspatialTspatial wraps MEOS C function overbelow_tspatial_tspatial. -func OverbelowTspatialTspatial(temp1 *Temporal, temp2 *Temporal) bool { +func OverbelowTspatialTspatial(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbelow_tspatial_tspatial(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverfrontSTBOXTspatial wraps MEOS C function overfront_stbox_tspatial. -func OverfrontSTBOXTspatial(box *STBox, temp *Temporal) bool { +func OverfrontSTBOXTspatial(box *STBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overfront_stbox_tspatial(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverfrontTspatialSTBOX wraps MEOS C function overfront_tspatial_stbox. -func OverfrontTspatialSTBOX(temp *Temporal, box *STBox) bool { +func OverfrontTspatialSTBOX(temp *Temporal, box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overfront_tspatial_stbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverfrontTspatialTspatial wraps MEOS C function overfront_tspatial_tspatial. -func OverfrontTspatialTspatial(temp1 *Temporal, temp2 *Temporal) bool { +func OverfrontTspatialTspatial(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overfront_tspatial_tspatial(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftSTBOXTspatial wraps MEOS C function overleft_stbox_tspatial. -func OverleftSTBOXTspatial(box *STBox, temp *Temporal) bool { +func OverleftSTBOXTspatial(box *STBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_stbox_tspatial(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftTspatialSTBOX wraps MEOS C function overleft_tspatial_stbox. -func OverleftTspatialSTBOX(temp *Temporal, box *STBox) bool { +func OverleftTspatialSTBOX(temp *Temporal, box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_tspatial_stbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftTspatialTspatial wraps MEOS C function overleft_tspatial_tspatial. -func OverleftTspatialTspatial(temp1 *Temporal, temp2 *Temporal) bool { +func OverleftTspatialTspatial(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_tspatial_tspatial(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightSTBOXTspatial wraps MEOS C function overright_stbox_tspatial. -func OverrightSTBOXTspatial(box *STBox, temp *Temporal) bool { +func OverrightSTBOXTspatial(box *STBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_stbox_tspatial(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightTspatialSTBOX wraps MEOS C function overright_tspatial_stbox. -func OverrightTspatialSTBOX(temp *Temporal, box *STBox) bool { +func OverrightTspatialSTBOX(temp *Temporal, box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_tspatial_stbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightTspatialTspatial wraps MEOS C function overright_tspatial_tspatial. -func OverrightTspatialTspatial(temp1 *Temporal, temp2 *Temporal) bool { +func OverrightTspatialTspatial(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_tspatial_tspatial(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightSTBOXTspatial wraps MEOS C function right_stbox_tspatial. -func RightSTBOXTspatial(box *STBox, temp *Temporal) bool { +func RightSTBOXTspatial(box *STBox, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_stbox_tspatial(box._inner, temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightTspatialSTBOX wraps MEOS C function right_tspatial_stbox. -func RightTspatialSTBOX(temp *Temporal, box *STBox) bool { +func RightTspatialSTBOX(temp *Temporal, box *STBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_tspatial_stbox(temp._inner, box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightTspatialTspatial wraps MEOS C function right_tspatial_tspatial. -func RightTspatialTspatial(temp1 *Temporal, temp2 *Temporal) bool { +func RightTspatialTspatial(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_tspatial_tspatial(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AcontainsGeoTgeo wraps MEOS C function acontains_geo_tgeo. -func AcontainsGeoTgeo(gs *Geom, temp *Temporal) int { +func AcontainsGeoTgeo(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.acontains_geo_tgeo(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AcontainsTgeoGeo wraps MEOS C function acontains_tgeo_geo. -func AcontainsTgeoGeo(temp *Temporal, gs *Geom) int { +func AcontainsTgeoGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.acontains_tgeo_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AcontainsTgeoTgeo wraps MEOS C function acontains_tgeo_tgeo. -func AcontainsTgeoTgeo(temp1 *Temporal, temp2 *Temporal) int { +func AcontainsTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.acontains_tgeo_tgeo(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AcoversGeoTgeo wraps MEOS C function acovers_geo_tgeo. -func AcoversGeoTgeo(gs *Geom, temp *Temporal) int { +func AcoversGeoTgeo(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.acovers_geo_tgeo(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AcoversTgeoGeo wraps MEOS C function acovers_tgeo_geo. -func AcoversTgeoGeo(temp *Temporal, gs *Geom) int { +func AcoversTgeoGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.acovers_tgeo_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AcoversTgeoTgeo wraps MEOS C function acovers_tgeo_tgeo. -func AcoversTgeoTgeo(temp1 *Temporal, temp2 *Temporal) int { +func AcoversTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.acovers_tgeo_tgeo(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AdisjointGeoTgeo wraps MEOS C function adisjoint_geo_tgeo. -func AdisjointGeoTgeo(gs *Geom, temp *Temporal) int { +func AdisjointGeoTgeo(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.adisjoint_geo_tgeo(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AdisjointTgeoGeo wraps MEOS C function adisjoint_tgeo_geo. -func AdisjointTgeoGeo(temp *Temporal, gs *Geom) int { +func AdisjointTgeoGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.adisjoint_tgeo_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AdisjointTgeoTgeo wraps MEOS C function adisjoint_tgeo_tgeo. -func AdisjointTgeoTgeo(temp1 *Temporal, temp2 *Temporal) int { +func AdisjointTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.adisjoint_tgeo_tgeo(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AdwithinGeoTgeo wraps MEOS C function adwithin_geo_tgeo. -func AdwithinGeoTgeo(gs *Geom, temp *Temporal, dist float64) int { +func AdwithinGeoTgeo(gs *Geom, temp *Temporal, dist float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.adwithin_geo_tgeo(gs._inner, temp._inner, C.double(dist)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AdwithinTgeoGeo wraps MEOS C function adwithin_tgeo_geo. -func AdwithinTgeoGeo(temp *Temporal, gs *Geom, dist float64) int { +func AdwithinTgeoGeo(temp *Temporal, gs *Geom, dist float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.adwithin_tgeo_geo(temp._inner, gs._inner, C.double(dist)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AdwithinTgeoTgeo wraps MEOS C function adwithin_tgeo_tgeo. -func AdwithinTgeoTgeo(temp1 *Temporal, temp2 *Temporal, dist float64) int { +func AdwithinTgeoTgeo(temp1 *Temporal, temp2 *Temporal, dist float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.adwithin_tgeo_tgeo(temp1._inner, temp2._inner, C.double(dist)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AintersectsGeoTgeo wraps MEOS C function aintersects_geo_tgeo. -func AintersectsGeoTgeo(gs *Geom, temp *Temporal) int { +func AintersectsGeoTgeo(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.aintersects_geo_tgeo(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AintersectsTgeoGeo wraps MEOS C function aintersects_tgeo_geo. -func AintersectsTgeoGeo(temp *Temporal, gs *Geom) int { +func AintersectsTgeoGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.aintersects_tgeo_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AintersectsTgeoTgeo wraps MEOS C function aintersects_tgeo_tgeo. -func AintersectsTgeoTgeo(temp1 *Temporal, temp2 *Temporal) int { +func AintersectsTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.aintersects_tgeo_tgeo(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AtouchesGeoTgeo wraps MEOS C function atouches_geo_tgeo. -func AtouchesGeoTgeo(gs *Geom, temp *Temporal) int { +func AtouchesGeoTgeo(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.atouches_geo_tgeo(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AtouchesTgeoGeo wraps MEOS C function atouches_tgeo_geo. -func AtouchesTgeoGeo(temp *Temporal, gs *Geom) int { +func AtouchesTgeoGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.atouches_tgeo_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AtouchesTgeoTgeo wraps MEOS C function atouches_tgeo_tgeo. -func AtouchesTgeoTgeo(temp1 *Temporal, temp2 *Temporal) int { +func AtouchesTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.atouches_tgeo_tgeo(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AtouchesTpointGeo wraps MEOS C function atouches_tpoint_geo. -func AtouchesTpointGeo(temp *Temporal, gs *Geom) int { +func AtouchesTpointGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.atouches_tpoint_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AtouchesGeoTpoint wraps MEOS C function atouches_geo_tpoint. -func AtouchesGeoTpoint(gs *Geom, temp *Temporal) int { +func AtouchesGeoTpoint(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.atouches_geo_tpoint(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EcontainsGeoTgeo wraps MEOS C function econtains_geo_tgeo. -func EcontainsGeoTgeo(gs *Geom, temp *Temporal) int { +func EcontainsGeoTgeo(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.econtains_geo_tgeo(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EcontainsTgeoGeo wraps MEOS C function econtains_tgeo_geo. -func EcontainsTgeoGeo(temp *Temporal, gs *Geom) int { +func EcontainsTgeoGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.econtains_tgeo_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EcontainsTgeoTgeo wraps MEOS C function econtains_tgeo_tgeo. -func EcontainsTgeoTgeo(temp1 *Temporal, temp2 *Temporal) int { +func EcontainsTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.econtains_tgeo_tgeo(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EcoversGeoTgeo wraps MEOS C function ecovers_geo_tgeo. -func EcoversGeoTgeo(gs *Geom, temp *Temporal) int { +func EcoversGeoTgeo(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ecovers_geo_tgeo(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EcoversTgeoGeo wraps MEOS C function ecovers_tgeo_geo. -func EcoversTgeoGeo(temp *Temporal, gs *Geom) int { +func EcoversTgeoGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ecovers_tgeo_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EcoversTgeoTgeo wraps MEOS C function ecovers_tgeo_tgeo. -func EcoversTgeoTgeo(temp1 *Temporal, temp2 *Temporal) int { +func EcoversTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ecovers_tgeo_tgeo(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EdisjointGeoTgeo wraps MEOS C function edisjoint_geo_tgeo. -func EdisjointGeoTgeo(gs *Geom, temp *Temporal) int { +func EdisjointGeoTgeo(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.edisjoint_geo_tgeo(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EdisjointTgeoGeo wraps MEOS C function edisjoint_tgeo_geo. -func EdisjointTgeoGeo(temp *Temporal, gs *Geom) int { +func EdisjointTgeoGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.edisjoint_tgeo_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EdisjointTgeoTgeo wraps MEOS C function edisjoint_tgeo_tgeo. -func EdisjointTgeoTgeo(temp1 *Temporal, temp2 *Temporal) int { +func EdisjointTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.edisjoint_tgeo_tgeo(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EdwithinGeoTgeo wraps MEOS C function edwithin_geo_tgeo. -func EdwithinGeoTgeo(gs *Geom, temp *Temporal, dist float64) int { +func EdwithinGeoTgeo(gs *Geom, temp *Temporal, dist float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.edwithin_geo_tgeo(gs._inner, temp._inner, C.double(dist)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EdwithinTgeoGeo wraps MEOS C function edwithin_tgeo_geo. -func EdwithinTgeoGeo(temp *Temporal, gs *Geom, dist float64) int { +func EdwithinTgeoGeo(temp *Temporal, gs *Geom, dist float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.edwithin_tgeo_geo(temp._inner, gs._inner, C.double(dist)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EdwithinTgeoTgeo wraps MEOS C function edwithin_tgeo_tgeo. -func EdwithinTgeoTgeo(temp1 *Temporal, temp2 *Temporal, dist float64) int { +func EdwithinTgeoTgeo(temp1 *Temporal, temp2 *Temporal, dist float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.edwithin_tgeo_tgeo(temp1._inner, temp2._inner, C.double(dist)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EintersectsGeoTgeo wraps MEOS C function eintersects_geo_tgeo. -func EintersectsGeoTgeo(gs *Geom, temp *Temporal) int { +func EintersectsGeoTgeo(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.eintersects_geo_tgeo(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EintersectsTgeoGeo wraps MEOS C function eintersects_tgeo_geo. -func EintersectsTgeoGeo(temp *Temporal, gs *Geom) int { +func EintersectsTgeoGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.eintersects_tgeo_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EintersectsTgeoTgeo wraps MEOS C function eintersects_tgeo_tgeo. -func EintersectsTgeoTgeo(temp1 *Temporal, temp2 *Temporal) int { +func EintersectsTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.eintersects_tgeo_tgeo(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EtouchesGeoTgeo wraps MEOS C function etouches_geo_tgeo. -func EtouchesGeoTgeo(gs *Geom, temp *Temporal) int { +func EtouchesGeoTgeo(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.etouches_geo_tgeo(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EtouchesTgeoGeo wraps MEOS C function etouches_tgeo_geo. -func EtouchesTgeoGeo(temp *Temporal, gs *Geom) int { +func EtouchesTgeoGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.etouches_tgeo_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EtouchesTgeoTgeo wraps MEOS C function etouches_tgeo_tgeo. -func EtouchesTgeoTgeo(temp1 *Temporal, temp2 *Temporal) int { +func EtouchesTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.etouches_tgeo_tgeo(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EtouchesTpointGeo wraps MEOS C function etouches_tpoint_geo. -func EtouchesTpointGeo(temp *Temporal, gs *Geom) int { +func EtouchesTpointGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.etouches_tpoint_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EtouchesGeoTpoint wraps MEOS C function etouches_geo_tpoint. -func EtouchesGeoTpoint(gs *Geom, temp *Temporal) int { +func EtouchesGeoTpoint(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.etouches_geo_tpoint(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TcontainsGeoTgeo wraps MEOS C function tcontains_geo_tgeo. -func TcontainsGeoTgeo(gs *Geom, temp *Temporal) *Temporal { +func TcontainsGeoTgeo(gs *Geom, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcontains_geo_tgeo(gs._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcontainsTgeoGeo wraps MEOS C function tcontains_tgeo_geo. -func TcontainsTgeoGeo(temp *Temporal, gs *Geom) *Temporal { +func TcontainsTgeoGeo(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcontains_tgeo_geo(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcontainsTgeoTgeo wraps MEOS C function tcontains_tgeo_tgeo. -func TcontainsTgeoTgeo(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TcontainsTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcontains_tgeo_tgeo(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcoversGeoTgeo wraps MEOS C function tcovers_geo_tgeo. -func TcoversGeoTgeo(gs *Geom, temp *Temporal) *Temporal { +func TcoversGeoTgeo(gs *Geom, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcovers_geo_tgeo(gs._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcoversTgeoGeo wraps MEOS C function tcovers_tgeo_geo. -func TcoversTgeoGeo(temp *Temporal, gs *Geom) *Temporal { +func TcoversTgeoGeo(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcovers_tgeo_geo(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TcoversTgeoTgeo wraps MEOS C function tcovers_tgeo_tgeo. -func TcoversTgeoTgeo(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TcoversTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tcovers_tgeo_tgeo(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdisjointGeoTgeo wraps MEOS C function tdisjoint_geo_tgeo. -func TdisjointGeoTgeo(gs *Geom, temp *Temporal) *Temporal { +func TdisjointGeoTgeo(gs *Geom, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdisjoint_geo_tgeo(gs._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdisjointTgeoGeo wraps MEOS C function tdisjoint_tgeo_geo. -func TdisjointTgeoGeo(temp *Temporal, gs *Geom) *Temporal { +func TdisjointTgeoGeo(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdisjoint_tgeo_geo(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdisjointTgeoTgeo wraps MEOS C function tdisjoint_tgeo_tgeo. -func TdisjointTgeoTgeo(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TdisjointTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdisjoint_tgeo_tgeo(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdwithinGeoTgeo wraps MEOS C function tdwithin_geo_tgeo. -func TdwithinGeoTgeo(gs *Geom, temp *Temporal, dist float64) *Temporal { +func TdwithinGeoTgeo(gs *Geom, temp *Temporal, dist float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdwithin_geo_tgeo(gs._inner, temp._inner, C.double(dist)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdwithinTgeoGeo wraps MEOS C function tdwithin_tgeo_geo. -func TdwithinTgeoGeo(temp *Temporal, gs *Geom, dist float64) *Temporal { +func TdwithinTgeoGeo(temp *Temporal, gs *Geom, dist float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdwithin_tgeo_geo(temp._inner, gs._inner, C.double(dist)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdwithinTgeoTgeo wraps MEOS C function tdwithin_tgeo_tgeo. -func TdwithinTgeoTgeo(temp1 *Temporal, temp2 *Temporal, dist float64) *Temporal { +func TdwithinTgeoTgeo(temp1 *Temporal, temp2 *Temporal, dist float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdwithin_tgeo_tgeo(temp1._inner, temp2._inner, C.double(dist)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TintersectsGeoTgeo wraps MEOS C function tintersects_geo_tgeo. -func TintersectsGeoTgeo(gs *Geom, temp *Temporal) *Temporal { +func TintersectsGeoTgeo(gs *Geom, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tintersects_geo_tgeo(gs._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TintersectsTgeoGeo wraps MEOS C function tintersects_tgeo_geo. -func TintersectsTgeoGeo(temp *Temporal, gs *Geom) *Temporal { +func TintersectsTgeoGeo(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tintersects_tgeo_geo(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TintersectsTgeoTgeo wraps MEOS C function tintersects_tgeo_tgeo. -func TintersectsTgeoTgeo(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TintersectsTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tintersects_tgeo_tgeo(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TtouchesGeoTgeo wraps MEOS C function ttouches_geo_tgeo. -func TtouchesGeoTgeo(gs *Geom, temp *Temporal) *Temporal { +func TtouchesGeoTgeo(gs *Geom, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.ttouches_geo_tgeo(gs._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TtouchesTgeoGeo wraps MEOS C function ttouches_tgeo_geo. -func TtouchesTgeoGeo(temp *Temporal, gs *Geom) *Temporal { +func TtouchesTgeoGeo(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.ttouches_tgeo_geo(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TtouchesTgeoTgeo wraps MEOS C function ttouches_tgeo_tgeo. -func TtouchesTgeoTgeo(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TtouchesTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.ttouches_tgeo_tgeo(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // EdwithinTgeoarrTgeoarr wraps MEOS C function edwithin_tgeoarr_tgeoarr. -func EdwithinTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, dist float64, count unsafe.Pointer) unsafe.Pointer { +func EdwithinTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, dist float64, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.edwithin_tgeoarr_tgeoarr((**C.Temporal)(unsafe.Pointer(arr1)), C.int(count1), (**C.Temporal)(unsafe.Pointer(arr2)), C.int(count2), C.double(dist), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // AdwithinTgeoarrTgeoarr wraps MEOS C function adwithin_tgeoarr_tgeoarr. -func AdwithinTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, dist float64, count unsafe.Pointer) unsafe.Pointer { +func AdwithinTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, dist float64, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.adwithin_tgeoarr_tgeoarr((**C.Temporal)(unsafe.Pointer(arr1)), C.int(count1), (**C.Temporal)(unsafe.Pointer(arr2)), C.int(count2), C.double(dist), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // EintersectsTgeoarrTgeoarr wraps MEOS C function eintersects_tgeoarr_tgeoarr. -func EintersectsTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, count unsafe.Pointer) unsafe.Pointer { +func EintersectsTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.eintersects_tgeoarr_tgeoarr((**C.Temporal)(unsafe.Pointer(arr1)), C.int(count1), (**C.Temporal)(unsafe.Pointer(arr2)), C.int(count2), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // AintersectsTgeoarrTgeoarr wraps MEOS C function aintersects_tgeoarr_tgeoarr. -func AintersectsTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, count unsafe.Pointer) unsafe.Pointer { +func AintersectsTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.aintersects_tgeoarr_tgeoarr((**C.Temporal)(unsafe.Pointer(arr1)), C.int(count1), (**C.Temporal)(unsafe.Pointer(arr2)), C.int(count2), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // EtouchesTgeoarrTgeoarr wraps MEOS C function etouches_tgeoarr_tgeoarr. -func EtouchesTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, count unsafe.Pointer) unsafe.Pointer { +func EtouchesTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.etouches_tgeoarr_tgeoarr((**C.Temporal)(unsafe.Pointer(arr1)), C.int(count1), (**C.Temporal)(unsafe.Pointer(arr2)), C.int(count2), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // AtouchesTgeoarrTgeoarr wraps MEOS C function atouches_tgeoarr_tgeoarr. -func AtouchesTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, count unsafe.Pointer) unsafe.Pointer { +func AtouchesTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.atouches_tgeoarr_tgeoarr((**C.Temporal)(unsafe.Pointer(arr1)), C.int(count1), (**C.Temporal)(unsafe.Pointer(arr2)), C.int(count2), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // EdisjointTgeoarrTgeoarr wraps MEOS C function edisjoint_tgeoarr_tgeoarr. -func EdisjointTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, count unsafe.Pointer) unsafe.Pointer { +func EdisjointTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.edisjoint_tgeoarr_tgeoarr((**C.Temporal)(unsafe.Pointer(arr1)), C.int(count1), (**C.Temporal)(unsafe.Pointer(arr2)), C.int(count2), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // AdisjointTgeoarrTgeoarr wraps MEOS C function adisjoint_tgeoarr_tgeoarr. -func AdisjointTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, count unsafe.Pointer) unsafe.Pointer { +func AdisjointTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.adisjoint_tgeoarr_tgeoarr((**C.Temporal)(unsafe.Pointer(arr1)), C.int(count1), (**C.Temporal)(unsafe.Pointer(arr2)), C.int(count2), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TdwithinTgeoarrTgeoarr wraps MEOS C function tdwithin_tgeoarr_tgeoarr. -func TdwithinTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, dist float64, count unsafe.Pointer, periods unsafe.Pointer) unsafe.Pointer { +func TdwithinTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, dist float64, count unsafe.Pointer, periods unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tdwithin_tgeoarr_tgeoarr((**C.Temporal)(unsafe.Pointer(arr1)), C.int(count1), (**C.Temporal)(unsafe.Pointer(arr2)), C.int(count2), C.double(dist), (*C.int)(unsafe.Pointer(count)), (***C.SpanSet)(unsafe.Pointer(periods))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TintersectsTgeoarrTgeoarr wraps MEOS C function tintersects_tgeoarr_tgeoarr. -func TintersectsTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, count unsafe.Pointer, periods unsafe.Pointer) unsafe.Pointer { +func TintersectsTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, count unsafe.Pointer, periods unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tintersects_tgeoarr_tgeoarr((**C.Temporal)(unsafe.Pointer(arr1)), C.int(count1), (**C.Temporal)(unsafe.Pointer(arr2)), C.int(count2), (*C.int)(unsafe.Pointer(count)), (***C.SpanSet)(unsafe.Pointer(periods))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TtouchesTgeoarrTgeoarr wraps MEOS C function ttouches_tgeoarr_tgeoarr. -func TtouchesTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, count unsafe.Pointer, periods unsafe.Pointer) unsafe.Pointer { +func TtouchesTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, count unsafe.Pointer, periods unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.ttouches_tgeoarr_tgeoarr((**C.Temporal)(unsafe.Pointer(arr1)), C.int(count1), (**C.Temporal)(unsafe.Pointer(arr2)), C.int(count2), (*C.int)(unsafe.Pointer(count)), (***C.SpanSet)(unsafe.Pointer(periods))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TdisjointTgeoarrTgeoarr wraps MEOS C function tdisjoint_tgeoarr_tgeoarr. -func TdisjointTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, count unsafe.Pointer, periods unsafe.Pointer) unsafe.Pointer { +func TdisjointTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int, count unsafe.Pointer, periods unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tdisjoint_tgeoarr_tgeoarr((**C.Temporal)(unsafe.Pointer(arr1)), C.int(count1), (**C.Temporal)(unsafe.Pointer(arr2)), C.int(count2), (*C.int)(unsafe.Pointer(count)), (***C.SpanSet)(unsafe.Pointer(periods))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TdistanceTgeoGeo wraps MEOS C function tdistance_tgeo_geo. -func TdistanceTgeoGeo(temp *Temporal, gs *Geom) *Temporal { +func TdistanceTgeoGeo(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdistance_tgeo_geo(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdistanceTgeoTgeo wraps MEOS C function tdistance_tgeo_tgeo. -func TdistanceTgeoTgeo(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TdistanceTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdistance_tgeo_tgeo(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // NadSTBOXGeo wraps MEOS C function nad_stbox_geo. -func NadSTBOXGeo(box *STBox, gs *Geom) float64 { +func NadSTBOXGeo(box *STBox, gs *Geom) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_stbox_geo(box._inner, gs._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NadSTBOXSTBOX wraps MEOS C function nad_stbox_stbox. -func NadSTBOXSTBOX(box1 *STBox, box2 *STBox) float64 { +func NadSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_stbox_stbox(box1._inner, box2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // STBOXSpatialDistance wraps MEOS C function stbox_spatial_distance. -func STBOXSpatialDistance(box1 *STBox, box2 *STBox) float64 { +func STBOXSpatialDistance(box1 *STBox, box2 *STBox) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.stbox_spatial_distance(box1._inner, box2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NadTgeoGeo wraps MEOS C function nad_tgeo_geo. -func NadTgeoGeo(temp *Temporal, gs *Geom) float64 { +func NadTgeoGeo(temp *Temporal, gs *Geom) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_tgeo_geo(temp._inner, gs._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NadTgeoSTBOX wraps MEOS C function nad_tgeo_stbox. -func NadTgeoSTBOX(temp *Temporal, box *STBox) float64 { +func NadTgeoSTBOX(temp *Temporal, box *STBox) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_tgeo_stbox(temp._inner, box._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NadTgeoTgeo wraps MEOS C function nad_tgeo_tgeo. -func NadTgeoTgeo(temp1 *Temporal, temp2 *Temporal) float64 { +func NadTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_tgeo_tgeo(temp1._inner, temp2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NaiTgeoGeo wraps MEOS C function nai_tgeo_geo. -func NaiTgeoGeo(temp *Temporal, gs *Geom) *TInstant { +func NaiTgeoGeo(temp *Temporal, gs *Geom) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.nai_tgeo_geo(temp._inner, gs._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // NaiTgeoTgeo wraps MEOS C function nai_tgeo_tgeo. -func NaiTgeoTgeo(temp1 *Temporal, temp2 *Temporal) *TInstant { +func NaiTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.nai_tgeo_tgeo(temp1._inner, temp2._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // ShortestlineTgeoGeo wraps MEOS C function shortestline_tgeo_geo. -func ShortestlineTgeoGeo(temp *Temporal, gs *Geom) *Geom { +func ShortestlineTgeoGeo(temp *Temporal, gs *Geom) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.shortestline_tgeo_geo(temp._inner, gs._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // ShortestlineTgeoTgeo wraps MEOS C function shortestline_tgeo_tgeo. -func ShortestlineTgeoTgeo(temp1 *Temporal, temp2 *Temporal) *Geom { +func ShortestlineTgeoTgeo(temp1 *Temporal, temp2 *Temporal) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.shortestline_tgeo_tgeo(temp1._inner, temp2._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // MindistanceTgeoTgeo wraps MEOS C function mindistance_tgeo_tgeo. -func MindistanceTgeoTgeo(temp1 *Temporal, temp2 *Temporal, threshold float64) float64 { +func MindistanceTgeoTgeo(temp1 *Temporal, temp2 *Temporal, threshold float64) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.mindistance_tgeo_tgeo(temp1._inner, temp2._inner, C.double(threshold)) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // MindistanceTgeoarrTgeoarr wraps MEOS C function mindistance_tgeoarr_tgeoarr. -func MindistanceTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int) float64 { +func MindistanceTgeoarrTgeoarr(arr1 unsafe.Pointer, count1 int, arr2 unsafe.Pointer, count2 int) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.mindistance_tgeoarr_tgeoarr((**C.Temporal)(unsafe.Pointer(arr1)), C.int(count1), (**C.Temporal)(unsafe.Pointer(arr2)), C.int(count2)) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TpointTcentroidFinalfn wraps MEOS C function tpoint_tcentroid_finalfn. -func TpointTcentroidFinalfn(state *SkipList) *Temporal { +func TpointTcentroidFinalfn(state *SkipList) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpoint_tcentroid_finalfn(state._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpointTcentroidTransfn wraps MEOS C function tpoint_tcentroid_transfn. -func TpointTcentroidTransfn(state *SkipList, temp *Temporal) *SkipList { +func TpointTcentroidTransfn(state *SkipList, temp *Temporal) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tpoint_tcentroid_transfn(state._inner, temp._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // TspatialExtentTransfn wraps MEOS C function tspatial_extent_transfn. -func TspatialExtentTransfn(box *STBox, temp *Temporal) *STBox { +func TspatialExtentTransfn(box *STBox, temp *Temporal) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.tspatial_extent_transfn(box._inner, temp._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // STBOXGetSpaceTile wraps MEOS C function stbox_get_space_tile. -func STBOXGetSpaceTile(point *Geom, xsize float64, ysize float64, zsize float64, sorigin *Geom) *STBox { +func STBOXGetSpaceTile(point *Geom, xsize float64, ysize float64, zsize float64, sorigin *Geom) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.stbox_get_space_tile(point._inner, C.double(xsize), C.double(ysize), C.double(zsize), sorigin._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // STBOXGetSpaceTimeTile wraps MEOS C function stbox_get_space_time_tile. -func STBOXGetSpaceTimeTile(point *Geom, t int64, xsize float64, ysize float64, zsize float64, duration *Interval, sorigin *Geom, torigin int64) *STBox { +func STBOXGetSpaceTimeTile(point *Geom, t int64, xsize float64, ysize float64, zsize float64, duration *Interval, sorigin *Geom, torigin int64) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.stbox_get_space_time_tile(point._inner, C.TimestampTz(t), C.double(xsize), C.double(ysize), C.double(zsize), duration._inner, sorigin._inner, C.TimestampTz(torigin)) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // STBOXGetTimeTile wraps MEOS C function stbox_get_time_tile. -func STBOXGetTimeTile(t int64, duration *Interval, torigin int64) *STBox { +func STBOXGetTimeTile(t int64, duration *Interval, torigin int64) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.stbox_get_time_tile(C.TimestampTz(t), duration._inner, C.TimestampTz(torigin)) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // STBOXSpaceTiles wraps MEOS C function stbox_space_tiles. -func STBOXSpaceTiles(bounds *STBox, xsize float64, ysize float64, zsize float64, sorigin *Geom, border_inc bool, count unsafe.Pointer) *STBox { +func STBOXSpaceTiles(bounds *STBox, xsize float64, ysize float64, zsize float64, sorigin *Geom, border_inc bool, count unsafe.Pointer) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.stbox_space_tiles(bounds._inner, C.double(xsize), C.double(ysize), C.double(zsize), sorigin._inner, C.bool(border_inc), (*C.int)(unsafe.Pointer(count))) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // STBOXSpaceTimeTiles wraps MEOS C function stbox_space_time_tiles. -func STBOXSpaceTimeTiles(bounds *STBox, xsize float64, ysize float64, zsize float64, duration *Interval, sorigin *Geom, torigin int64, border_inc bool, count unsafe.Pointer) *STBox { +func STBOXSpaceTimeTiles(bounds *STBox, xsize float64, ysize float64, zsize float64, duration *Interval, sorigin *Geom, torigin int64, border_inc bool, count unsafe.Pointer) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.stbox_space_time_tiles(bounds._inner, C.double(xsize), C.double(ysize), C.double(zsize), duration._inner, sorigin._inner, C.TimestampTz(torigin), C.bool(border_inc), (*C.int)(unsafe.Pointer(count))) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // STBOXTimeTiles wraps MEOS C function stbox_time_tiles. -func STBOXTimeTiles(bounds *STBox, duration *Interval, torigin int64, border_inc bool, count unsafe.Pointer) *STBox { +func STBOXTimeTiles(bounds *STBox, duration *Interval, torigin int64, border_inc bool, count unsafe.Pointer) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.stbox_time_tiles(bounds._inner, duration._inner, C.TimestampTz(torigin), C.bool(border_inc), (*C.int)(unsafe.Pointer(count))) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } @@ -3274,29 +5046,45 @@ func STBOXTimeTiles(bounds *STBox, duration *Interval, torigin int64, border_inc // GeoClusterKmeans wraps MEOS C function geo_cluster_kmeans. -func GeoClusterKmeans(geoms unsafe.Pointer, ngeoms uint32, k uint32, count unsafe.Pointer) unsafe.Pointer { +func GeoClusterKmeans(geoms unsafe.Pointer, ngeoms uint32, k uint32, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.geo_cluster_kmeans((**C.GSERIALIZED)(unsafe.Pointer(geoms)), C.uint32_t(ngeoms), C.uint32_t(k), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // GeoClusterDbscan wraps MEOS C function geo_cluster_dbscan. -func GeoClusterDbscan(geoms unsafe.Pointer, ngeoms uint32, tolerance float64, minpoints int, count unsafe.Pointer) unsafe.Pointer { +func GeoClusterDbscan(geoms unsafe.Pointer, ngeoms uint32, tolerance float64, minpoints int, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.geo_cluster_dbscan((**C.GSERIALIZED)(unsafe.Pointer(geoms)), C.uint32_t(ngeoms), C.double(tolerance), C.int(minpoints), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // GeoClusterIntersecting wraps MEOS C function geo_cluster_intersecting. -func GeoClusterIntersecting(geoms unsafe.Pointer, ngeoms uint32, count unsafe.Pointer) unsafe.Pointer { +func GeoClusterIntersecting(geoms unsafe.Pointer, ngeoms uint32, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.geo_cluster_intersecting((**C.GSERIALIZED)(unsafe.Pointer(geoms)), C.uint32_t(ngeoms), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // GeoClusterWithin wraps MEOS C function geo_cluster_within. -func GeoClusterWithin(geoms unsafe.Pointer, ngeoms uint32, tolerance float64, count unsafe.Pointer) unsafe.Pointer { +func GeoClusterWithin(geoms unsafe.Pointer, ngeoms uint32, tolerance float64, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.geo_cluster_within((**C.GSERIALIZED)(unsafe.Pointer(geoms)), C.uint32_t(ngeoms), C.double(tolerance), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } diff --git a/functions/meos_meos_h3.go b/functions/meos_meos_h3.go index 9ac9370..5f22888 100644 --- a/functions/meos_meos_h3.go +++ b/functions/meos_meos_h3.go @@ -86,537 +86,833 @@ import ( var _ = unsafe.Pointer(nil) // H3indexFromWKB wraps MEOS C function h3index_from_wkb. -func H3indexFromWKB(wkb unsafe.Pointer, size uint) uint64 { +func H3indexFromWKB(wkb unsafe.Pointer, size uint) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.h3index_from_wkb((*C.uint8_t)(unsafe.Pointer(wkb)), C.size_t(size)) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // H3indexFromHexwkb wraps MEOS C function h3index_from_hexwkb. -func H3indexFromHexwkb(hexwkb string) uint64 { +func H3indexFromHexwkb(hexwkb string) (_r0 uint64, _err error) { _c_hexwkb := C.CString(hexwkb) defer C.free(unsafe.Pointer(_c_hexwkb)) + C.meos_errno_reset() _cret := C.h3index_from_hexwkb(_c_hexwkb) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // H3indexAsWKB wraps MEOS C function h3index_as_wkb. -func H3indexAsWKB(cell uint64, variant uint8, size_out unsafe.Pointer) unsafe.Pointer { +func H3indexAsWKB(cell uint64, variant uint8, size_out unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.h3index_as_wkb(C.uint64_t(cell), C.uint8_t(variant), (*C.size_t)(unsafe.Pointer(size_out))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // H3indexAsHexwkb wraps MEOS C function h3index_as_hexwkb. -func H3indexAsHexwkb(cell uint64, variant uint8, size_out unsafe.Pointer) string { +func H3indexAsHexwkb(cell uint64, variant uint8, size_out unsafe.Pointer) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.h3index_as_hexwkb(C.uint64_t(cell), C.uint8_t(variant), (*C.size_t)(unsafe.Pointer(size_out))) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // Th3indexIn wraps MEOS C function th3index_in. -func Th3indexIn(str string) *Temporal { +func Th3indexIn(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.th3index_in(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexinstIn wraps MEOS C function th3indexinst_in. -func Th3indexinstIn(str string) *TInstant { +func Th3indexinstIn(str string) (_r0 *TInstant, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.th3indexinst_in(_c_str) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // Th3indexseqIn wraps MEOS C function th3indexseq_in. -func Th3indexseqIn(str string, interp Interpolation) *TSequence { +func Th3indexseqIn(str string, interp Interpolation) (_r0 *TSequence, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.th3indexseq_in(_c_str, C.interpType(interp)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // Th3indexseqsetIn wraps MEOS C function th3indexseqset_in. -func Th3indexseqsetIn(str string) *TSequenceSet { +func Th3indexseqsetIn(str string) (_r0 *TSequenceSet, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.th3indexseqset_in(_c_str) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // Th3indexMake wraps MEOS C function th3index_make. -func Th3indexMake(value uint64, t int64) *Temporal { +func Th3indexMake(value uint64, t int64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_make(C.uint64_t(value), C.TimestampTz(t)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexinstMake wraps MEOS C function th3indexinst_make. -func Th3indexinstMake(value uint64, t int64) *TInstant { +func Th3indexinstMake(value uint64, t int64) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.th3indexinst_make(C.uint64_t(value), C.TimestampTz(t)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // Th3indexseqMake wraps MEOS C function th3indexseq_make. -func Th3indexseqMake(values unsafe.Pointer, times unsafe.Pointer, count int, lower_inc bool, upper_inc bool) *TSequence { +func Th3indexseqMake(values unsafe.Pointer, times unsafe.Pointer, count int, lower_inc bool, upper_inc bool) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.th3indexseq_make((*C.uint64_t)(unsafe.Pointer(values)), (*C.TimestampTz)(unsafe.Pointer(times)), C.int(count), C.bool(lower_inc), C.bool(upper_inc)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // Th3indexseqsetMake wraps MEOS C function th3indexseqset_make. -func Th3indexseqsetMake(sequences unsafe.Pointer, count int) *TSequenceSet { +func Th3indexseqsetMake(sequences unsafe.Pointer, count int) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.th3indexseqset_make((**C.TSequence)(unsafe.Pointer(sequences)), C.int(count)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // Th3indexStartValue wraps MEOS C function th3index_start_value. -func Th3indexStartValue(temp *Temporal) uint64 { +func Th3indexStartValue(temp *Temporal) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.th3index_start_value(temp._inner) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // Th3indexEndValue wraps MEOS C function th3index_end_value. -func Th3indexEndValue(temp *Temporal) uint64 { +func Th3indexEndValue(temp *Temporal) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.th3index_end_value(temp._inner) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // Th3indexValueN wraps MEOS C function th3index_value_n. -func Th3indexValueN(temp *Temporal, n int) (bool, uint64) { +func Th3indexValueN(temp *Temporal, n int) (_r0 bool, _r1 uint64, _err error) { var _out_result C.uint64_t + C.meos_errno_reset() _cret := C.th3index_value_n(temp._inner, C.int(n), &_out_result) - return bool(_cret), uint64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), uint64(_out_result), nil } // Th3indexValues wraps MEOS C function th3index_values. -func Th3indexValues(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func Th3indexValues(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.th3index_values(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // Th3indexValueAtTimestamptz wraps MEOS C function th3index_value_at_timestamptz. -func Th3indexValueAtTimestamptz(temp *Temporal, t int64, strict bool) (bool, uint64) { +func Th3indexValueAtTimestamptz(temp *Temporal, t int64, strict bool) (_r0 bool, _r1 uint64, _err error) { var _out_result C.uint64_t + C.meos_errno_reset() _cret := C.th3index_value_at_timestamptz(temp._inner, C.TimestampTz(t), C.bool(strict), &_out_result) - return bool(_cret), uint64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), uint64(_out_result), nil } // TbigintToTh3index wraps MEOS C function tbigint_to_th3index. -func TbigintToTh3index(temp *Temporal) *Temporal { +func TbigintToTh3index(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tbigint_to_th3index(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexToTbigint wraps MEOS C function th3index_to_tbigint. -func Th3indexToTbigint(temp *Temporal) *Temporal { +func Th3indexToTbigint(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_to_tbigint(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // EverEqH3indexTh3index wraps MEOS C function ever_eq_h3index_th3index. -func EverEqH3indexTh3index(cell uint64, temp *Temporal) int { +func EverEqH3indexTh3index(cell uint64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_h3index_th3index(C.uint64_t(cell), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTh3indexH3index wraps MEOS C function ever_eq_th3index_h3index. -func EverEqTh3indexH3index(temp *Temporal, cell uint64) int { +func EverEqTh3indexH3index(temp *Temporal, cell uint64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_th3index_h3index(temp._inner, C.uint64_t(cell)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeH3indexTh3index wraps MEOS C function ever_ne_h3index_th3index. -func EverNeH3indexTh3index(cell uint64, temp *Temporal) int { +func EverNeH3indexTh3index(cell uint64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_h3index_th3index(C.uint64_t(cell), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTh3indexH3index wraps MEOS C function ever_ne_th3index_h3index. -func EverNeTh3indexH3index(temp *Temporal, cell uint64) int { +func EverNeTh3indexH3index(temp *Temporal, cell uint64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_th3index_h3index(temp._inner, C.uint64_t(cell)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqH3indexTh3index wraps MEOS C function always_eq_h3index_th3index. -func AlwaysEqH3indexTh3index(cell uint64, temp *Temporal) int { +func AlwaysEqH3indexTh3index(cell uint64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_h3index_th3index(C.uint64_t(cell), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTh3indexH3index wraps MEOS C function always_eq_th3index_h3index. -func AlwaysEqTh3indexH3index(temp *Temporal, cell uint64) int { +func AlwaysEqTh3indexH3index(temp *Temporal, cell uint64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_th3index_h3index(temp._inner, C.uint64_t(cell)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeH3indexTh3index wraps MEOS C function always_ne_h3index_th3index. -func AlwaysNeH3indexTh3index(cell uint64, temp *Temporal) int { +func AlwaysNeH3indexTh3index(cell uint64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_h3index_th3index(C.uint64_t(cell), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTh3indexH3index wraps MEOS C function always_ne_th3index_h3index. -func AlwaysNeTh3indexH3index(temp *Temporal, cell uint64) int { +func AlwaysNeTh3indexH3index(temp *Temporal, cell uint64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_th3index_h3index(temp._inner, C.uint64_t(cell)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTh3indexTh3index wraps MEOS C function ever_eq_th3index_th3index. -func EverEqTh3indexTh3index(temp1 *Temporal, temp2 *Temporal) int { +func EverEqTh3indexTh3index(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_th3index_th3index(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTh3indexTh3index wraps MEOS C function ever_ne_th3index_th3index. -func EverNeTh3indexTh3index(temp1 *Temporal, temp2 *Temporal) int { +func EverNeTh3indexTh3index(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_th3index_th3index(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTh3indexTh3index wraps MEOS C function always_eq_th3index_th3index. -func AlwaysEqTh3indexTh3index(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysEqTh3indexTh3index(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_th3index_th3index(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTh3indexTh3index wraps MEOS C function always_ne_th3index_th3index. -func AlwaysNeTh3indexTh3index(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysNeTh3indexTh3index(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_th3index_th3index(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TeqH3indexTh3index wraps MEOS C function teq_h3index_th3index. -func TeqH3indexTh3index(cell uint64, temp *Temporal) *Temporal { +func TeqH3indexTh3index(cell uint64, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_h3index_th3index(C.uint64_t(cell), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TeqTh3indexH3index wraps MEOS C function teq_th3index_h3index. -func TeqTh3indexH3index(temp *Temporal, cell uint64) *Temporal { +func TeqTh3indexH3index(temp *Temporal, cell uint64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_th3index_h3index(temp._inner, C.uint64_t(cell)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TeqTh3indexTh3index wraps MEOS C function teq_th3index_th3index. -func TeqTh3indexTh3index(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TeqTh3indexTh3index(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_th3index_th3index(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneH3indexTh3index wraps MEOS C function tne_h3index_th3index. -func TneH3indexTh3index(cell uint64, temp *Temporal) *Temporal { +func TneH3indexTh3index(cell uint64, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_h3index_th3index(C.uint64_t(cell), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneTh3indexH3index wraps MEOS C function tne_th3index_h3index. -func TneTh3indexH3index(temp *Temporal, cell uint64) *Temporal { +func TneTh3indexH3index(temp *Temporal, cell uint64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_th3index_h3index(temp._inner, C.uint64_t(cell)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneTh3indexTh3index wraps MEOS C function tne_th3index_th3index. -func TneTh3indexTh3index(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TneTh3indexTh3index(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_th3index_th3index(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexGetResolution wraps MEOS C function th3index_get_resolution. -func Th3indexGetResolution(temp *Temporal) *Temporal { +func Th3indexGetResolution(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_get_resolution(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexGetBaseCellNumber wraps MEOS C function th3index_get_base_cell_number. -func Th3indexGetBaseCellNumber(temp *Temporal) *Temporal { +func Th3indexGetBaseCellNumber(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_get_base_cell_number(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexIsValidCell wraps MEOS C function th3index_is_valid_cell. -func Th3indexIsValidCell(temp *Temporal) *Temporal { +func Th3indexIsValidCell(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_is_valid_cell(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexIsResClassIii wraps MEOS C function th3index_is_res_class_iii. -func Th3indexIsResClassIii(temp *Temporal) *Temporal { +func Th3indexIsResClassIii(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_is_res_class_iii(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexIsPentagon wraps MEOS C function th3index_is_pentagon. -func Th3indexIsPentagon(temp *Temporal) *Temporal { +func Th3indexIsPentagon(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_is_pentagon(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexCellToParent wraps MEOS C function th3index_cell_to_parent. -func Th3indexCellToParent(temp *Temporal, resolution int32) *Temporal { +func Th3indexCellToParent(temp *Temporal, resolution int32) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_cell_to_parent(temp._inner, C.int32(resolution)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexCellToParentNext wraps MEOS C function th3index_cell_to_parent_next. -func Th3indexCellToParentNext(temp *Temporal) *Temporal { +func Th3indexCellToParentNext(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_cell_to_parent_next(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexCellToCenterChild wraps MEOS C function th3index_cell_to_center_child. -func Th3indexCellToCenterChild(temp *Temporal, resolution int32) *Temporal { +func Th3indexCellToCenterChild(temp *Temporal, resolution int32) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_cell_to_center_child(temp._inner, C.int32(resolution)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexCellToCenterChildNext wraps MEOS C function th3index_cell_to_center_child_next. -func Th3indexCellToCenterChildNext(temp *Temporal) *Temporal { +func Th3indexCellToCenterChildNext(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_cell_to_center_child_next(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexCellToChildPos wraps MEOS C function th3index_cell_to_child_pos. -func Th3indexCellToChildPos(temp *Temporal, parent_res int32) *Temporal { +func Th3indexCellToChildPos(temp *Temporal, parent_res int32) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_cell_to_child_pos(temp._inner, C.int32(parent_res)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexChildPosToCell wraps MEOS C function th3index_child_pos_to_cell. -func Th3indexChildPosToCell(child_pos *Temporal, parent *Temporal, child_res int32) *Temporal { +func Th3indexChildPosToCell(child_pos *Temporal, parent *Temporal, child_res int32) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_child_pos_to_cell(child_pos._inner, parent._inner, C.int32(child_res)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeogpointToTh3index wraps MEOS C function tgeogpoint_to_th3index. -func TgeogpointToTh3index(temp *Temporal, resolution int32) *Temporal { +func TgeogpointToTh3index(temp *Temporal, resolution int32) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeogpoint_to_th3index(temp._inner, C.int32(resolution)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeompointToTh3index wraps MEOS C function tgeompoint_to_th3index. -func TgeompointToTh3index(temp *Temporal, resolution int32) *Temporal { +func TgeompointToTh3index(temp *Temporal, resolution int32) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeompoint_to_th3index(temp._inner, C.int32(resolution)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexToTgeogpoint wraps MEOS C function th3index_to_tgeogpoint. -func Th3indexToTgeogpoint(temp *Temporal) *Temporal { +func Th3indexToTgeogpoint(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_to_tgeogpoint(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexToTgeompoint wraps MEOS C function th3index_to_tgeompoint. -func Th3indexToTgeompoint(temp *Temporal) *Temporal { +func Th3indexToTgeompoint(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_to_tgeompoint(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexCellToBoundary wraps MEOS C function th3index_cell_to_boundary. -func Th3indexCellToBoundary(temp *Temporal) *Temporal { +func Th3indexCellToBoundary(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_cell_to_boundary(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // GeoToH3indexCell wraps MEOS C function geo_to_h3index_cell. -func GeoToH3indexCell(point *Geom, resolution int32) uint64 { +func GeoToH3indexCell(point *Geom, resolution int32) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.geo_to_h3index_cell(point._inner, C.int32(resolution)) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // GeoToH3indexSet wraps MEOS C function geo_to_h3index_set. -func GeoToH3indexSet(gs *Geom, resolution int32) *Set { +func GeoToH3indexSet(gs *Geom, resolution int32) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.geo_to_h3index_set(gs._inner, C.int32(resolution)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // H3indexToSTBOX wraps MEOS C function h3index_to_stbox. -func H3indexToSTBOX(cell uint64) *STBox { +func H3indexToSTBOX(cell uint64) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.h3index_to_stbox(C.uint64_t(cell)) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // H3indexTimestamptzToSTBOX wraps MEOS C function h3index_timestamptz_to_stbox. -func H3indexTimestamptzToSTBOX(cell uint64, t int64) *STBox { +func H3indexTimestamptzToSTBOX(cell uint64, t int64) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.h3index_timestamptz_to_stbox(C.uint64_t(cell), C.TimestampTz(t)) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // H3indexTstzspanToSTBOX wraps MEOS C function h3index_tstzspan_to_stbox. -func H3indexTstzspanToSTBOX(cell uint64, s *Span) *STBox { +func H3indexTstzspanToSTBOX(cell uint64, s *Span) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.h3index_tstzspan_to_stbox(C.uint64_t(cell), s._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // EverEqH3indexsetTh3index wraps MEOS C function ever_eq_h3indexset_th3index. -func EverEqH3indexsetTh3index(cells *Set, th3idx *Temporal) int { +func EverEqH3indexsetTh3index(cells *Set, th3idx *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_h3indexset_th3index(cells._inner, th3idx._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // Th3indexAreNeighborCells wraps MEOS C function th3index_are_neighbor_cells. -func Th3indexAreNeighborCells(origin *Temporal, dest *Temporal) *Temporal { +func Th3indexAreNeighborCells(origin *Temporal, dest *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_are_neighbor_cells(origin._inner, dest._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexCellsToDirectedEdge wraps MEOS C function th3index_cells_to_directed_edge. -func Th3indexCellsToDirectedEdge(origin *Temporal, dest *Temporal) *Temporal { +func Th3indexCellsToDirectedEdge(origin *Temporal, dest *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_cells_to_directed_edge(origin._inner, dest._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexIsValidDirectedEdge wraps MEOS C function th3index_is_valid_directed_edge. -func Th3indexIsValidDirectedEdge(edge *Temporal) *Temporal { +func Th3indexIsValidDirectedEdge(edge *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_is_valid_directed_edge(edge._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexGetDirectedEdgeOrigin wraps MEOS C function th3index_get_directed_edge_origin. -func Th3indexGetDirectedEdgeOrigin(edge *Temporal) *Temporal { +func Th3indexGetDirectedEdgeOrigin(edge *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_get_directed_edge_origin(edge._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexGetDirectedEdgeDestination wraps MEOS C function th3index_get_directed_edge_destination. -func Th3indexGetDirectedEdgeDestination(edge *Temporal) *Temporal { +func Th3indexGetDirectedEdgeDestination(edge *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_get_directed_edge_destination(edge._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexDirectedEdgeToBoundary wraps MEOS C function th3index_directed_edge_to_boundary. -func Th3indexDirectedEdgeToBoundary(edge *Temporal) *Temporal { +func Th3indexDirectedEdgeToBoundary(edge *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_directed_edge_to_boundary(edge._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexCellToVertex wraps MEOS C function th3index_cell_to_vertex. -func Th3indexCellToVertex(temp *Temporal, vertex_num int32) *Temporal { +func Th3indexCellToVertex(temp *Temporal, vertex_num int32) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_cell_to_vertex(temp._inner, C.int32(vertex_num)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexVertexToLatlng wraps MEOS C function th3index_vertex_to_latlng. -func Th3indexVertexToLatlng(temp *Temporal) *Temporal { +func Th3indexVertexToLatlng(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_vertex_to_latlng(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexIsValidVertex wraps MEOS C function th3index_is_valid_vertex. -func Th3indexIsValidVertex(temp *Temporal) *Temporal { +func Th3indexIsValidVertex(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_is_valid_vertex(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexGridDistance wraps MEOS C function th3index_grid_distance. -func Th3indexGridDistance(origin *Temporal, dest *Temporal) *Temporal { +func Th3indexGridDistance(origin *Temporal, dest *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_grid_distance(origin._inner, dest._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexCellToLocalIj wraps MEOS C function th3index_cell_to_local_ij. -func Th3indexCellToLocalIj(origin *Temporal, cell *Temporal) *Temporal { +func Th3indexCellToLocalIj(origin *Temporal, cell *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_cell_to_local_ij(origin._inner, cell._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexLocalIjToCell wraps MEOS C function th3index_local_ij_to_cell. -func Th3indexLocalIjToCell(origin *Temporal, coord *Temporal) *Temporal { +func Th3indexLocalIjToCell(origin *Temporal, coord *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.th3index_local_ij_to_cell(origin._inner, coord._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexCellArea wraps MEOS C function th3index_cell_area. -func Th3indexCellArea(temp *Temporal, unit string) *Temporal { +func Th3indexCellArea(temp *Temporal, unit string) (_r0 *Temporal, _err error) { _c_unit := C.CString(unit) defer C.free(unsafe.Pointer(_c_unit)) + C.meos_errno_reset() _cret := C.th3index_cell_area(temp._inner, _c_unit) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // Th3indexEdgeLength wraps MEOS C function th3index_edge_length. -func Th3indexEdgeLength(temp *Temporal, unit string) *Temporal { +func Th3indexEdgeLength(temp *Temporal, unit string) (_r0 *Temporal, _err error) { _c_unit := C.CString(unit) defer C.free(unsafe.Pointer(_c_unit)) + C.meos_errno_reset() _cret := C.th3index_edge_length(temp._inner, _c_unit) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeogpointGreatCircleDistance wraps MEOS C function tgeogpoint_great_circle_distance. -func TgeogpointGreatCircleDistance(a *Temporal, b *Temporal, unit string) *Temporal { +func TgeogpointGreatCircleDistance(a *Temporal, b *Temporal, unit string) (_r0 *Temporal, _err error) { _c_unit := C.CString(unit) defer C.free(unsafe.Pointer(_c_unit)) + C.meos_errno_reset() _cret := C.tgeogpoint_great_circle_distance(a._inner, b._inner, _c_unit) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } diff --git a/functions/meos_meos_internal.go b/functions/meos_meos_internal.go index d8dd254..82015c9 100644 --- a/functions/meos_meos_internal.go +++ b/functions/meos_meos_internal.go @@ -86,1822 +86,2893 @@ import ( var _ = unsafe.Pointer(nil) // GslGetGenerationRng wraps MEOS C function gsl_get_generation_rng. -func GslGetGenerationRng() *GslRng { +func GslGetGenerationRng() (_r0 *GslRng, _err error) { + C.meos_errno_reset() _cret := C.gsl_get_generation_rng() - return &GslRng{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &GslRng{_inner: _cret}, nil } // GslGetAggregationRng wraps MEOS C function gsl_get_aggregation_rng. -func GslGetAggregationRng() *GslRng { +func GslGetAggregationRng() (_r0 *GslRng, _err error) { + C.meos_errno_reset() _cret := C.gsl_get_aggregation_rng() - return &GslRng{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &GslRng{_inner: _cret}, nil } // FloatspanRoundSet wraps MEOS C function floatspan_round_set. -func FloatspanRoundSet(s *Span, maxdd int) *Span { +func FloatspanRoundSet(s *Span, maxdd int) (_r0 *Span, _err error) { var _out_result C.Span + C.meos_errno_reset() C.floatspan_round_set(s._inner, C.int(maxdd), &_out_result) - return &Span{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: &_out_result}, nil } // SetIn wraps MEOS C function set_in. -func SetIn(str string, basetype MeosType) *Set { +func SetIn(str string, basetype MeosType) (_r0 *Set, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.set_in(_c_str, C.MeosType(basetype)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // SetOut wraps MEOS C function set_out. -func SetOut(s *Set, maxdd int) string { +func SetOut(s *Set, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.set_out(s._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // SpanIn wraps MEOS C function span_in. -func SpanIn(str string, spantype MeosType) *Span { +func SpanIn(str string, spantype MeosType) (_r0 *Span, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.span_in(_c_str, C.MeosType(spantype)) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // SpanOut wraps MEOS C function span_out. -func SpanOut(s *Span, maxdd int) string { +func SpanOut(s *Span, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.span_out(s._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // SpansetIn wraps MEOS C function spanset_in. -func SpansetIn(str string, spantype MeosType) *SpanSet { +func SpansetIn(str string, spantype MeosType) (_r0 *SpanSet, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.spanset_in(_c_str, C.MeosType(spantype)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // SpansetOut wraps MEOS C function spanset_out. -func SpansetOut(ss *SpanSet, maxdd int) string { +func SpansetOut(ss *SpanSet, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.spanset_out(ss._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // SpansetMakeExp wraps MEOS C function spanset_make_exp. -func SpansetMakeExp(spans *Span, count int, maxcount int, normalize bool, order bool) *SpanSet { +func SpansetMakeExp(spans *Span, count int, maxcount int, normalize bool, order bool) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.spanset_make_exp(spans._inner, C.int(count), C.int(maxcount), C.bool(normalize), C.bool(order)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // SpansetMakeFree wraps MEOS C function spanset_make_free. -func SpansetMakeFree(spans *Span, count int, normalize bool, order bool) *SpanSet { +func SpansetMakeFree(spans *Span, count int, normalize bool, order bool) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.spanset_make_free(spans._inner, C.int(count), C.bool(normalize), C.bool(order)) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // SetSpan wraps MEOS C function set_span. -func SetSpan(s *Set) *Span { +func SetSpan(s *Set) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.set_span(s._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // SetSpanset wraps MEOS C function set_spanset. -func SetSpanset(s *Set) *SpanSet { +func SetSpanset(s *Set) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.set_spanset(s._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // SetMemSize wraps MEOS C function set_mem_size. -func SetMemSize(s *Set) int { +func SetMemSize(s *Set) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.set_mem_size(s._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // SetSetSubspan wraps MEOS C function set_set_subspan. -func SetSetSubspan(s *Set, minidx int, maxidx int) *Span { +func SetSetSubspan(s *Set, minidx int, maxidx int) (_r0 *Span, _err error) { var _out_result C.Span + C.meos_errno_reset() C.set_set_subspan(s._inner, C.int(minidx), C.int(maxidx), &_out_result) - return &Span{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: &_out_result}, nil } // SetSetSpan wraps MEOS C function set_set_span. -func SetSetSpan(s *Set) *Span { +func SetSetSpan(s *Set) (_r0 *Span, _err error) { var _out_result C.Span + C.meos_errno_reset() C.set_set_span(s._inner, &_out_result) - return &Span{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: &_out_result}, nil } // SpansetMemSize wraps MEOS C function spanset_mem_size. -func SpansetMemSize(ss *SpanSet) int { +func SpansetMemSize(ss *SpanSet) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.spanset_mem_size(ss._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // SpansetSps wraps MEOS C function spanset_sps. -func SpansetSps(ss *SpanSet, count unsafe.Pointer) unsafe.Pointer { +func SpansetSps(ss *SpanSet, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.spanset_sps(ss._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // DatespanSetTstzspan wraps MEOS C function datespan_set_tstzspan. -func DatespanSetTstzspan(s1 *Span, s2 *Span) { +func DatespanSetTstzspan(s1 *Span, s2 *Span) (_err error) { + C.meos_errno_reset() C.datespan_set_tstzspan(s1._inner, s2._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // BigintspanSetFloatspan wraps MEOS C function bigintspan_set_floatspan. -func BigintspanSetFloatspan(s1 *Span, s2 *Span) { +func BigintspanSetFloatspan(s1 *Span, s2 *Span) (_err error) { + C.meos_errno_reset() C.bigintspan_set_floatspan(s1._inner, s2._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // BigintspanSetIntspan wraps MEOS C function bigintspan_set_intspan. -func BigintspanSetIntspan(s1 *Span, s2 *Span) { +func BigintspanSetIntspan(s1 *Span, s2 *Span) (_err error) { + C.meos_errno_reset() C.bigintspan_set_intspan(s1._inner, s2._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // FloatspanSetBigintspan wraps MEOS C function floatspan_set_bigintspan. -func FloatspanSetBigintspan(s1 *Span, s2 *Span) { +func FloatspanSetBigintspan(s1 *Span, s2 *Span) (_err error) { + C.meos_errno_reset() C.floatspan_set_bigintspan(s1._inner, s2._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // FloatspanSetIntspan wraps MEOS C function floatspan_set_intspan. -func FloatspanSetIntspan(s1 *Span, s2 *Span) { +func FloatspanSetIntspan(s1 *Span, s2 *Span) (_err error) { + C.meos_errno_reset() C.floatspan_set_intspan(s1._inner, s2._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // IntspanSetBigintspan wraps MEOS C function intspan_set_bigintspan. -func IntspanSetBigintspan(s1 *Span, s2 *Span) { +func IntspanSetBigintspan(s1 *Span, s2 *Span) (_err error) { + C.meos_errno_reset() C.intspan_set_bigintspan(s1._inner, s2._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // IntspanSetFloatspan wraps MEOS C function intspan_set_floatspan. -func IntspanSetFloatspan(s1 *Span, s2 *Span) { +func IntspanSetFloatspan(s1 *Span, s2 *Span) (_err error) { + C.meos_errno_reset() C.intspan_set_floatspan(s1._inner, s2._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // SetCompact wraps MEOS C function set_compact. -func SetCompact(s *Set) *Set { +func SetCompact(s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.set_compact(s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // SpanExpand wraps MEOS C function span_expand. -func SpanExpand(s1 *Span, s2 *Span) { +func SpanExpand(s1 *Span, s2 *Span) (_err error) { + C.meos_errno_reset() C.span_expand(s1._inner, s2._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // SuperUnionSpanSpan wraps MEOS C function super_union_span_span. -func SuperUnionSpanSpan(s1 *Span, s2 *Span) *Span { +func SuperUnionSpanSpan(s1 *Span, s2 *Span) (_r0 *Span, _err error) { + C.meos_errno_reset() _cret := C.super_union_span_span(s1._inner, s2._inner) - return &Span{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: _cret}, nil } // SpansetCompact wraps MEOS C function spanset_compact. -func SpansetCompact(ss *SpanSet) *SpanSet { +func SpansetCompact(ss *SpanSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.spanset_compact(ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // TextcatTextsetTextCommon wraps MEOS C function textcat_textset_text_common. -func TextcatTextsetTextCommon(s *Set, txt string, invert bool) *Set { +func TextcatTextsetTextCommon(s *Set, txt string, invert bool) (_r0 *Set, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.textcat_textset_text_common(s._inner, _c_txt, C.bool(invert)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TstzspanSetDatespan wraps MEOS C function tstzspan_set_datespan. -func TstzspanSetDatespan(s1 *Span, s2 *Span) { +func TstzspanSetDatespan(s1 *Span, s2 *Span) (_err error) { + C.meos_errno_reset() C.tstzspan_set_datespan(s1._inner, s2._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // OvadjSpanSpan wraps MEOS C function ovadj_span_span. -func OvadjSpanSpan(s1 *Span, s2 *Span) bool { +func OvadjSpanSpan(s1 *Span, s2 *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.ovadj_span_span(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LfnadjSpanSpan wraps MEOS C function lfnadj_span_span. -func LfnadjSpanSpan(s1 *Span, s2 *Span) bool { +func LfnadjSpanSpan(s1 *Span, s2 *Span) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.lfnadj_span_span(s1._inner, s2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BboxType wraps MEOS C function bbox_type. -func BboxType(bboxtype MeosType) bool { +func BboxType(bboxtype MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.bbox_type(C.MeosType(bboxtype)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BboxGetSize wraps MEOS C function bbox_get_size. -func BboxGetSize(bboxtype MeosType) uint { +func BboxGetSize(bboxtype MeosType) (_r0 uint, _err error) { + C.meos_errno_reset() _cret := C.bbox_get_size(C.MeosType(bboxtype)) - return uint(_cret) + if _err = meosError(); _err != nil { + return + } + return uint(_cret), nil } // BboxMaxDims wraps MEOS C function bbox_max_dims. -func BboxMaxDims(bboxtype MeosType) int { +func BboxMaxDims(bboxtype MeosType) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.bbox_max_dims(C.MeosType(bboxtype)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TemporalBboxEq wraps MEOS C function temporal_bbox_eq. -func TemporalBboxEq(box1 unsafe.Pointer, box2 unsafe.Pointer, temptype MeosType) bool { +func TemporalBboxEq(box1 unsafe.Pointer, box2 unsafe.Pointer, temptype MeosType) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.temporal_bbox_eq(unsafe.Pointer(box1), unsafe.Pointer(box2), C.MeosType(temptype)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TemporalBboxCmp wraps MEOS C function temporal_bbox_cmp. -func TemporalBboxCmp(box1 unsafe.Pointer, box2 unsafe.Pointer, temptype MeosType) int { +func TemporalBboxCmp(box1 unsafe.Pointer, box2 unsafe.Pointer, temptype MeosType) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.temporal_bbox_cmp(unsafe.Pointer(box1), unsafe.Pointer(box2), C.MeosType(temptype)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EnsureBboxTemporalCompatible wraps MEOS C function ensure_bbox_temporal_compatible. -func EnsureBboxTemporalCompatible(bboxtype MeosType, temp *Temporal) bool { +func EnsureBboxTemporalCompatible(bboxtype MeosType, temp *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.ensure_bbox_temporal_compatible(C.MeosType(bboxtype), temp._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BboxTemporalSplitBoxes wraps MEOS C function bbox_temporal_split_boxes. -func BboxTemporalSplitBoxes(bboxtype MeosType, boxsize uint, temp *Temporal, maxboxes int, count unsafe.Pointer) unsafe.Pointer { +func BboxTemporalSplitBoxes(bboxtype MeosType, boxsize uint, temp *Temporal, maxboxes int, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _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) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // BboxUnionSpanSpan wraps MEOS C function bbox_union_span_span. -func BboxUnionSpanSpan(s1 *Span, s2 *Span) *Span { +func BboxUnionSpanSpan(s1 *Span, s2 *Span) (_r0 *Span, _err error) { var _out_result C.Span + C.meos_errno_reset() C.bbox_union_span_span(s1._inner, s2._inner, &_out_result) - return &Span{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return &Span{_inner: &_out_result}, nil } // InterSpanSpan wraps MEOS C function inter_span_span. -func InterSpanSpan(s1 *Span, s2 *Span) (bool, *Span) { +func InterSpanSpan(s1 *Span, s2 *Span) (_r0 bool, _r1 *Span, _err error) { var _out_result C.Span + C.meos_errno_reset() _cret := C.inter_span_span(s1._inner, s2._inner, &_out_result) - return bool(_cret), &Span{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Span{_inner: &_out_result}, nil } // MiSpanSpan wraps MEOS C function mi_span_span. -func MiSpanSpan(s1 *Span, s2 *Span) (int, *Span) { +func MiSpanSpan(s1 *Span, s2 *Span) (_r0 int, _r1 *Span, _err error) { var _out_result C.Span + C.meos_errno_reset() _cret := C.mi_span_span(s1._inner, s2._inner, &_out_result) - return int(_cret), &Span{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return int(_cret), &Span{_inner: &_out_result}, nil } // TBOXSet wraps MEOS C function tbox_set. -func TBOXSet(s *Span, p *Span, box *TBox) { +func TBOXSet(s *Span, p *Span, box *TBox) (_err error) { + C.meos_errno_reset() C.tbox_set(s._inner, p._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // FloatSetTBOX wraps MEOS C function float_set_tbox. -func FloatSetTBOX(d float64, box *TBox) { +func FloatSetTBOX(d float64, box *TBox) (_err error) { + C.meos_errno_reset() C.float_set_tbox(C.double(d), box._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // IntSetTBOX wraps MEOS C function int_set_tbox. -func IntSetTBOX(i int, box *TBox) { +func IntSetTBOX(i int, box *TBox) (_err error) { + C.meos_errno_reset() C.int_set_tbox(C.int(i), box._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // NumsetSetTBOX wraps MEOS C function numset_set_tbox. -func NumsetSetTBOX(s *Set, box *TBox) { +func NumsetSetTBOX(s *Set, box *TBox) (_err error) { + C.meos_errno_reset() C.numset_set_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // NumspanSetTBOX wraps MEOS C function numspan_set_tbox. -func NumspanSetTBOX(span *Span, box *TBox) { +func NumspanSetTBOX(span *Span, box *TBox) (_err error) { + C.meos_errno_reset() C.numspan_set_tbox(span._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // TimestamptzSetTBOX wraps MEOS C function timestamptz_set_tbox. -func TimestamptzSetTBOX(t int64, box *TBox) { +func TimestamptzSetTBOX(t int64, box *TBox) (_err error) { + C.meos_errno_reset() C.timestamptz_set_tbox(C.TimestampTz(t), box._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // TstzsetSetTBOX wraps MEOS C function tstzset_set_tbox. -func TstzsetSetTBOX(s *Set, box *TBox) { +func TstzsetSetTBOX(s *Set, box *TBox) (_err error) { + C.meos_errno_reset() C.tstzset_set_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // TstzspanSetTBOX wraps MEOS C function tstzspan_set_tbox. -func TstzspanSetTBOX(s *Span, box *TBox) { +func TstzspanSetTBOX(s *Span, box *TBox) (_err error) { + C.meos_errno_reset() C.tstzspan_set_tbox(s._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // TBOXExpand wraps MEOS C function tbox_expand. -func TBOXExpand(box1 *TBox, box2 *TBox) { +func TBOXExpand(box1 *TBox, box2 *TBox) (_err error) { + C.meos_errno_reset() C.tbox_expand(box1._inner, box2._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // InterTBOXTBOX wraps MEOS C function inter_tbox_tbox. -func InterTBOXTBOX(box1 *TBox, box2 *TBox) (bool, *TBox) { +func InterTBOXTBOX(box1 *TBox, box2 *TBox) (_r0 bool, _r1 *TBox, _err error) { var _out_result C.TBox + C.meos_errno_reset() _cret := C.inter_tbox_tbox(box1._inner, box2._inner, &_out_result) - return bool(_cret), &TBox{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &TBox{_inner: &_out_result}, nil } // TboolinstIn wraps MEOS C function tboolinst_in. -func TboolinstIn(str string) *TInstant { +func TboolinstIn(str string) (_r0 *TInstant, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tboolinst_in(_c_str) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TboolseqIn wraps MEOS C function tboolseq_in. -func TboolseqIn(str string, interp Interpolation) *TSequence { +func TboolseqIn(str string, interp Interpolation) (_r0 *TSequence, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tboolseq_in(_c_str, C.interpType(interp)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TboolseqsetIn wraps MEOS C function tboolseqset_in. -func TboolseqsetIn(str string) *TSequenceSet { +func TboolseqsetIn(str string) (_r0 *TSequenceSet, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tboolseqset_in(_c_str) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TemporalIn wraps MEOS C function temporal_in. -func TemporalIn(str string, temptype MeosType) *Temporal { +func TemporalIn(str string, temptype MeosType) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.temporal_in(_c_str, C.MeosType(temptype)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalOut wraps MEOS C function temporal_out. -func TemporalOut(temp *Temporal, maxdd int) string { +func TemporalOut(temp *Temporal, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.temporal_out(temp._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TemparrOut wraps MEOS C function temparr_out. -func TemparrOut(temparr unsafe.Pointer, count int, maxdd int) unsafe.Pointer { +func TemparrOut(temparr unsafe.Pointer, count int, maxdd int) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.temparr_out((**C.Temporal)(unsafe.Pointer(temparr)), C.int(count), C.int(maxdd)) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TfloatinstIn wraps MEOS C function tfloatinst_in. -func TfloatinstIn(str string) *TInstant { +func TfloatinstIn(str string) (_r0 *TInstant, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tfloatinst_in(_c_str) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TfloatseqIn wraps MEOS C function tfloatseq_in. -func TfloatseqIn(str string, interp Interpolation) *TSequence { +func TfloatseqIn(str string, interp Interpolation) (_r0 *TSequence, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tfloatseq_in(_c_str, C.interpType(interp)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TfloatseqsetIn wraps MEOS C function tfloatseqset_in. -func TfloatseqsetIn(str string) *TSequenceSet { +func TfloatseqsetIn(str string) (_r0 *TSequenceSet, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tfloatseqset_in(_c_str) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TinstantIn wraps MEOS C function tinstant_in. -func TinstantIn(str string, temptype MeosType) *TInstant { +func TinstantIn(str string, temptype MeosType) (_r0 *TInstant, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tinstant_in(_c_str, C.MeosType(temptype)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TinstantOut wraps MEOS C function tinstant_out. -func TinstantOut(inst *TInstant, maxdd int) string { +func TinstantOut(inst *TInstant, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.tinstant_out(inst._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TbigintinstIn wraps MEOS C function tbigintinst_in. -func TbigintinstIn(str string) *TInstant { +func TbigintinstIn(str string) (_r0 *TInstant, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tbigintinst_in(_c_str) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TbigintseqsetIn wraps MEOS C function tbigintseqset_in. -func TbigintseqsetIn(str string) *TSequenceSet { +func TbigintseqsetIn(str string) (_r0 *TSequenceSet, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tbigintseqset_in(_c_str) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TintinstIn wraps MEOS C function tintinst_in. -func TintinstIn(str string) *TInstant { +func TintinstIn(str string) (_r0 *TInstant, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tintinst_in(_c_str) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TintseqIn wraps MEOS C function tintseq_in. -func TintseqIn(str string, interp Interpolation) *TSequence { +func TintseqIn(str string, interp Interpolation) (_r0 *TSequence, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tintseq_in(_c_str, C.interpType(interp)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TintseqsetIn wraps MEOS C function tintseqset_in. -func TintseqsetIn(str string) *TSequenceSet { +func TintseqsetIn(str string) (_r0 *TSequenceSet, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tintseqset_in(_c_str) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequenceIn wraps MEOS C function tsequence_in. -func TsequenceIn(str string, temptype MeosType, interp Interpolation) *TSequence { +func TsequenceIn(str string, temptype MeosType, interp Interpolation) (_r0 *TSequence, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tsequence_in(_c_str, C.MeosType(temptype), C.interpType(interp)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TsequenceOut wraps MEOS C function tsequence_out. -func TsequenceOut(seq *TSequence, maxdd int) string { +func TsequenceOut(seq *TSequence, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.tsequence_out(seq._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TsequencesetIn wraps MEOS C function tsequenceset_in. -func TsequencesetIn(str string, temptype MeosType, interp Interpolation) *TSequenceSet { +func TsequencesetIn(str string, temptype MeosType, interp Interpolation) (_r0 *TSequenceSet, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tsequenceset_in(_c_str, C.MeosType(temptype), C.interpType(interp)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequencesetOut wraps MEOS C function tsequenceset_out. -func TsequencesetOut(ss *TSequenceSet, maxdd int) string { +func TsequencesetOut(ss *TSequenceSet, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_out(ss._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TtextinstIn wraps MEOS C function ttextinst_in. -func TtextinstIn(str string) *TInstant { +func TtextinstIn(str string) (_r0 *TInstant, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.ttextinst_in(_c_str) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TtextseqIn wraps MEOS C function ttextseq_in. -func TtextseqIn(str string, interp Interpolation) *TSequence { +func TtextseqIn(str string, interp Interpolation) (_r0 *TSequence, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.ttextseq_in(_c_str, C.interpType(interp)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TtextseqsetIn wraps MEOS C function ttextseqset_in. -func TtextseqsetIn(str string) *TSequenceSet { +func TtextseqsetIn(str string) (_r0 *TSequenceSet, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.ttextseqset_in(_c_str) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TemporalFromMFJSON wraps MEOS C function temporal_from_mfjson. -func TemporalFromMFJSON(mfjson string, temptype MeosType) *Temporal { +func TemporalFromMFJSON(mfjson string, temptype MeosType) (_r0 *Temporal, _err error) { _c_mfjson := C.CString(mfjson) defer C.free(unsafe.Pointer(_c_mfjson)) + C.meos_errno_reset() _cret := C.temporal_from_mfjson(_c_mfjson, C.MeosType(temptype)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TinstantCopy wraps MEOS C function tinstant_copy. -func TinstantCopy(inst *TInstant) *TInstant { +func TinstantCopy(inst *TInstant) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tinstant_copy(inst._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TsequenceCopy wraps MEOS C function tsequence_copy. -func TsequenceCopy(seq *TSequence) *TSequence { +func TsequenceCopy(seq *TSequence) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tsequence_copy(seq._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TsequenceMakeExp wraps MEOS C function tsequence_make_exp. -func TsequenceMakeExp(instants unsafe.Pointer, count int, maxcount int, lower_inc bool, upper_inc bool, interp Interpolation, normalize bool) *TSequence { +func TsequenceMakeExp(instants unsafe.Pointer, count int, maxcount int, lower_inc bool, upper_inc bool, interp Interpolation, normalize bool) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tsequence_make_exp((**C.TInstant)(unsafe.Pointer(instants)), C.int(count), C.int(maxcount), C.bool(lower_inc), C.bool(upper_inc), C.interpType(interp), C.bool(normalize)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TsequenceMakeFree wraps MEOS C function tsequence_make_free. -func TsequenceMakeFree(instants unsafe.Pointer, count int, lower_inc bool, upper_inc bool, interp Interpolation, normalize bool) *TSequence { +func TsequenceMakeFree(instants unsafe.Pointer, count int, lower_inc bool, upper_inc bool, interp Interpolation, normalize bool) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tsequence_make_free((**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} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TsequencesetCopy wraps MEOS C function tsequenceset_copy. -func TsequencesetCopy(ss *TSequenceSet) *TSequenceSet { +func TsequencesetCopy(ss *TSequenceSet) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_copy(ss._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TseqsetarrToTseqset wraps MEOS C function tseqsetarr_to_tseqset. -func TseqsetarrToTseqset(seqsets unsafe.Pointer, count int, totalseqs int) *TSequenceSet { +func TseqsetarrToTseqset(seqsets unsafe.Pointer, count int, totalseqs int) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tseqsetarr_to_tseqset((**C.TSequenceSet)(unsafe.Pointer(seqsets)), C.int(count), C.int(totalseqs)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequencesetMakeExp wraps MEOS C function tsequenceset_make_exp. -func TsequencesetMakeExp(sequences unsafe.Pointer, count int, maxcount int, normalize bool) *TSequenceSet { +func TsequencesetMakeExp(sequences unsafe.Pointer, count int, maxcount int, normalize bool) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_make_exp((**C.TSequence)(unsafe.Pointer(sequences)), C.int(count), C.int(maxcount), C.bool(normalize)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequencesetMakeFree wraps MEOS C function tsequenceset_make_free. -func TsequencesetMakeFree(sequences unsafe.Pointer, count int, normalize bool) *TSequenceSet { +func TsequencesetMakeFree(sequences unsafe.Pointer, count int, normalize bool) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_make_free((**C.TSequence)(unsafe.Pointer(sequences)), C.int(count), C.bool(normalize)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TemporalSetTstzspan wraps MEOS C function temporal_set_tstzspan. -func TemporalSetTstzspan(temp *Temporal, s *Span) { +func TemporalSetTstzspan(temp *Temporal, s *Span) (_err error) { + C.meos_errno_reset() C.temporal_set_tstzspan(temp._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // TemporalTimeOverlaps wraps MEOS C function temporal_time_overlaps. -func TemporalTimeOverlaps(temp1 *Temporal, temp2 *Temporal) bool { +func TemporalTimeOverlaps(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.temporal_time_overlaps(temp1._inner, temp2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TinstantSetTstzspan wraps MEOS C function tinstant_set_tstzspan. -func TinstantSetTstzspan(inst *TInstant, s *Span) { +func TinstantSetTstzspan(inst *TInstant, s *Span) (_err error) { + C.meos_errno_reset() C.tinstant_set_tstzspan(inst._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // TnumberSetTBOX wraps MEOS C function tnumber_set_tbox. -func TnumberSetTBOX(temp *Temporal, box *TBox) { +func TnumberSetTBOX(temp *Temporal, box *TBox) (_err error) { + C.meos_errno_reset() C.tnumber_set_tbox(temp._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // TnumberinstSetTBOX wraps MEOS C function tnumberinst_set_tbox. -func TnumberinstSetTBOX(inst *TInstant, box *TBox) { +func TnumberinstSetTBOX(inst *TInstant, box *TBox) (_err error) { + C.meos_errno_reset() C.tnumberinst_set_tbox(inst._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // TnumberseqSetTBOX wraps MEOS C function tnumberseq_set_tbox. -func TnumberseqSetTBOX(seq *TSequence, box *TBox) { +func TnumberseqSetTBOX(seq *TSequence, box *TBox) (_err error) { + C.meos_errno_reset() C.tnumberseq_set_tbox(seq._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // TnumberseqsetSetTBOX wraps MEOS C function tnumberseqset_set_tbox. -func TnumberseqsetSetTBOX(ss *TSequenceSet, box *TBox) { +func TnumberseqsetSetTBOX(ss *TSequenceSet, box *TBox) (_err error) { + C.meos_errno_reset() C.tnumberseqset_set_tbox(ss._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // TsequenceSetTstzspan wraps MEOS C function tsequence_set_tstzspan. -func TsequenceSetTstzspan(seq *TSequence, s *Span) { +func TsequenceSetTstzspan(seq *TSequence, s *Span) (_err error) { + C.meos_errno_reset() C.tsequence_set_tstzspan(seq._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // TsequencesetSetTstzspan wraps MEOS C function tsequenceset_set_tstzspan. -func TsequencesetSetTstzspan(ss *TSequenceSet, s *Span) { +func TsequencesetSetTstzspan(ss *TSequenceSet, s *Span) (_err error) { + C.meos_errno_reset() C.tsequenceset_set_tstzspan(ss._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // TemporalEndInst wraps MEOS C function temporal_end_inst. -func TemporalEndInst(temp *Temporal) *TInstant { +func TemporalEndInst(temp *Temporal) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.temporal_end_inst(temp._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TemporalInstN wraps MEOS C function temporal_inst_n. -func TemporalInstN(temp *Temporal, n int) *TInstant { +func TemporalInstN(temp *Temporal, n int) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.temporal_inst_n(temp._inner, C.int(n)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TemporalInstsP wraps MEOS C function temporal_insts_p. -func TemporalInstsP(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TemporalInstsP(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.temporal_insts_p(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TemporalMaxInstP wraps MEOS C function temporal_max_inst_p. -func TemporalMaxInstP(temp *Temporal) *TInstant { +func TemporalMaxInstP(temp *Temporal) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.temporal_max_inst_p(temp._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TemporalMemSize wraps MEOS C function temporal_mem_size. -func TemporalMemSize(temp *Temporal) uint { +func TemporalMemSize(temp *Temporal) (_r0 uint, _err error) { + C.meos_errno_reset() _cret := C.temporal_mem_size(temp._inner) - return uint(_cret) + if _err = meosError(); _err != nil { + return + } + return uint(_cret), nil } // TemporalMinInstP wraps MEOS C function temporal_min_inst_p. -func TemporalMinInstP(temp *Temporal) *TInstant { +func TemporalMinInstP(temp *Temporal) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.temporal_min_inst_p(temp._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TemporalSequencesP wraps MEOS C function temporal_sequences_p. -func TemporalSequencesP(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TemporalSequencesP(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.temporal_sequences_p(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TemporalSetBbox wraps MEOS C function temporal_set_bbox. -func TemporalSetBbox(temp *Temporal, box unsafe.Pointer) { +func TemporalSetBbox(temp *Temporal, box unsafe.Pointer) (_err error) { + C.meos_errno_reset() C.temporal_set_bbox(temp._inner, unsafe.Pointer(box)) + if _err = meosError(); _err != nil { + return + } + return nil } // TemporalStartInst wraps MEOS C function temporal_start_inst. -func TemporalStartInst(temp *Temporal) *TInstant { +func TemporalStartInst(temp *Temporal) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.temporal_start_inst(temp._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TinstantHash wraps MEOS C function tinstant_hash. -func TinstantHash(inst *TInstant) uint32 { +func TinstantHash(inst *TInstant) (_r0 uint32, _err error) { + C.meos_errno_reset() _cret := C.tinstant_hash(inst._inner) - return uint32(_cret) + if _err = meosError(); _err != nil { + return + } + return uint32(_cret), nil } // TinstantHashExtended wraps MEOS C function tinstant_hash_extended. -func TinstantHashExtended(inst *TInstant, seed uint64) uint64 { +func TinstantHashExtended(inst *TInstant, seed uint64) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.tinstant_hash_extended(inst._inner, C.uint64_t(seed)) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // TinstantInsts wraps MEOS C function tinstant_insts. -func TinstantInsts(inst *TInstant, count unsafe.Pointer) unsafe.Pointer { +func TinstantInsts(inst *TInstant, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tinstant_insts(inst._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TinstantSetBbox wraps MEOS C function tinstant_set_bbox. -func TinstantSetBbox(inst *TInstant, box unsafe.Pointer) { +func TinstantSetBbox(inst *TInstant, box unsafe.Pointer) (_err error) { + C.meos_errno_reset() C.tinstant_set_bbox(inst._inner, unsafe.Pointer(box)) + if _err = meosError(); _err != nil { + return + } + return nil } // TinstantTime wraps MEOS C function tinstant_time. -func TinstantTime(inst *TInstant) *SpanSet { +func TinstantTime(inst *TInstant) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.tinstant_time(inst._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // TinstantTimestamps wraps MEOS C function tinstant_timestamps. -func TinstantTimestamps(inst *TInstant, count unsafe.Pointer) unsafe.Pointer { +func TinstantTimestamps(inst *TInstant, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tinstant_timestamps(inst._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TnumberSetSpan wraps MEOS C function tnumber_set_span. -func TnumberSetSpan(temp *Temporal, s *Span) { +func TnumberSetSpan(temp *Temporal, s *Span) (_err error) { + C.meos_errno_reset() C.tnumber_set_span(temp._inner, s._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // TnumberinstValuespans wraps MEOS C function tnumberinst_valuespans. -func TnumberinstValuespans(inst *TInstant) *SpanSet { +func TnumberinstValuespans(inst *TInstant) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.tnumberinst_valuespans(inst._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // TnumberseqAvgVal wraps MEOS C function tnumberseq_avg_val. -func TnumberseqAvgVal(seq *TSequence) float64 { +func TnumberseqAvgVal(seq *TSequence) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.tnumberseq_avg_val(seq._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TnumberseqValuespans wraps MEOS C function tnumberseq_valuespans. -func TnumberseqValuespans(seq *TSequence) *SpanSet { +func TnumberseqValuespans(seq *TSequence) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.tnumberseq_valuespans(seq._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // TnumberseqsetAvgVal wraps MEOS C function tnumberseqset_avg_val. -func TnumberseqsetAvgVal(ss *TSequenceSet) float64 { +func TnumberseqsetAvgVal(ss *TSequenceSet) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.tnumberseqset_avg_val(ss._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TnumberseqsetValuespans wraps MEOS C function tnumberseqset_valuespans. -func TnumberseqsetValuespans(ss *TSequenceSet) *SpanSet { +func TnumberseqsetValuespans(ss *TSequenceSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.tnumberseqset_valuespans(ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // TsequenceDuration wraps MEOS C function tsequence_duration. -func TsequenceDuration(seq *TSequence) *Interval { +func TsequenceDuration(seq *TSequence) (_r0 *Interval, _err error) { + C.meos_errno_reset() _cret := C.tsequence_duration(seq._inner) - return &Interval{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Interval{_inner: _cret}, nil } // TsequenceEndTimestamptz wraps MEOS C function tsequence_end_timestamptz. -func TsequenceEndTimestamptz(seq *TSequence) int64 { +func TsequenceEndTimestamptz(seq *TSequence) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.tsequence_end_timestamptz(seq._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // TsequenceHash wraps MEOS C function tsequence_hash. -func TsequenceHash(seq *TSequence) uint32 { +func TsequenceHash(seq *TSequence) (_r0 uint32, _err error) { + C.meos_errno_reset() _cret := C.tsequence_hash(seq._inner) - return uint32(_cret) + if _err = meosError(); _err != nil { + return + } + return uint32(_cret), nil } // TsequenceHashExtended wraps MEOS C function tsequence_hash_extended. -func TsequenceHashExtended(seq *TSequence, seed uint64) uint64 { +func TsequenceHashExtended(seq *TSequence, seed uint64) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.tsequence_hash_extended(seq._inner, C.uint64_t(seed)) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // TsequenceInstsP wraps MEOS C function tsequence_insts_p. -func TsequenceInstsP(seq *TSequence, count unsafe.Pointer) unsafe.Pointer { +func TsequenceInstsP(seq *TSequence, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tsequence_insts_p(seq._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TsequenceMaxInstP wraps MEOS C function tsequence_max_inst_p. -func TsequenceMaxInstP(seq *TSequence) *TInstant { +func TsequenceMaxInstP(seq *TSequence) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tsequence_max_inst_p(seq._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TsequenceMinInstP wraps MEOS C function tsequence_min_inst_p. -func TsequenceMinInstP(seq *TSequence) *TInstant { +func TsequenceMinInstP(seq *TSequence) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tsequence_min_inst_p(seq._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TsequenceSegments wraps MEOS C function tsequence_segments. -func TsequenceSegments(seq *TSequence, count unsafe.Pointer) unsafe.Pointer { +func TsequenceSegments(seq *TSequence, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tsequence_segments(seq._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TsequenceSeqs wraps MEOS C function tsequence_seqs. -func TsequenceSeqs(seq *TSequence, count unsafe.Pointer) unsafe.Pointer { +func TsequenceSeqs(seq *TSequence, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tsequence_seqs(seq._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TsequenceStartTimestamptz wraps MEOS C function tsequence_start_timestamptz. -func TsequenceStartTimestamptz(seq *TSequence) int64 { +func TsequenceStartTimestamptz(seq *TSequence) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.tsequence_start_timestamptz(seq._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // TsequenceTime wraps MEOS C function tsequence_time. -func TsequenceTime(seq *TSequence) *SpanSet { +func TsequenceTime(seq *TSequence) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.tsequence_time(seq._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // TsequenceTimestamps wraps MEOS C function tsequence_timestamps. -func TsequenceTimestamps(seq *TSequence, count unsafe.Pointer) unsafe.Pointer { +func TsequenceTimestamps(seq *TSequence, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tsequence_timestamps(seq._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TsequencesetDuration wraps MEOS C function tsequenceset_duration. -func TsequencesetDuration(ss *TSequenceSet, boundspan bool) *Interval { +func TsequencesetDuration(ss *TSequenceSet, boundspan bool) (_r0 *Interval, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_duration(ss._inner, C.bool(boundspan)) - return &Interval{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Interval{_inner: _cret}, nil } // TsequencesetEndTimestamptz wraps MEOS C function tsequenceset_end_timestamptz. -func TsequencesetEndTimestamptz(ss *TSequenceSet) int64 { +func TsequencesetEndTimestamptz(ss *TSequenceSet) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_end_timestamptz(ss._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // TsequencesetHash wraps MEOS C function tsequenceset_hash. -func TsequencesetHash(ss *TSequenceSet) uint32 { +func TsequencesetHash(ss *TSequenceSet) (_r0 uint32, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_hash(ss._inner) - return uint32(_cret) + if _err = meosError(); _err != nil { + return + } + return uint32(_cret), nil } // TsequencesetHashExtended wraps MEOS C function tsequenceset_hash_extended. -func TsequencesetHashExtended(ss *TSequenceSet, seed uint64) uint64 { +func TsequencesetHashExtended(ss *TSequenceSet, seed uint64) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_hash_extended(ss._inner, C.uint64_t(seed)) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // TsequencesetInstN wraps MEOS C function tsequenceset_inst_n. -func TsequencesetInstN(ss *TSequenceSet, n int) *TInstant { +func TsequencesetInstN(ss *TSequenceSet, n int) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_inst_n(ss._inner, C.int(n)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TsequencesetInstsP wraps MEOS C function tsequenceset_insts_p. -func TsequencesetInstsP(ss *TSequenceSet, count unsafe.Pointer) unsafe.Pointer { +func TsequencesetInstsP(ss *TSequenceSet, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_insts_p(ss._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TsequencesetMaxInstP wraps MEOS C function tsequenceset_max_inst_p. -func TsequencesetMaxInstP(ss *TSequenceSet) *TInstant { +func TsequencesetMaxInstP(ss *TSequenceSet) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_max_inst_p(ss._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TsequencesetMinInstP wraps MEOS C function tsequenceset_min_inst_p. -func TsequencesetMinInstP(ss *TSequenceSet) *TInstant { +func TsequencesetMinInstP(ss *TSequenceSet) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_min_inst_p(ss._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TsequencesetNumInstants wraps MEOS C function tsequenceset_num_instants. -func TsequencesetNumInstants(ss *TSequenceSet) int { +func TsequencesetNumInstants(ss *TSequenceSet) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_num_instants(ss._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TsequencesetNumTimestamps wraps MEOS C function tsequenceset_num_timestamps. -func TsequencesetNumTimestamps(ss *TSequenceSet) int { +func TsequencesetNumTimestamps(ss *TSequenceSet) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_num_timestamps(ss._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TsequencesetSegments wraps MEOS C function tsequenceset_segments. -func TsequencesetSegments(ss *TSequenceSet, count unsafe.Pointer) unsafe.Pointer { +func TsequencesetSegments(ss *TSequenceSet, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_segments(ss._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TsequencesetSequencesP wraps MEOS C function tsequenceset_sequences_p. -func TsequencesetSequencesP(ss *TSequenceSet) unsafe.Pointer { +func TsequencesetSequencesP(ss *TSequenceSet) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_sequences_p(ss._inner) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TsequencesetStartTimestamptz wraps MEOS C function tsequenceset_start_timestamptz. -func TsequencesetStartTimestamptz(ss *TSequenceSet) int64 { +func TsequencesetStartTimestamptz(ss *TSequenceSet) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_start_timestamptz(ss._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // TsequencesetTime wraps MEOS C function tsequenceset_time. -func TsequencesetTime(ss *TSequenceSet) *SpanSet { +func TsequencesetTime(ss *TSequenceSet) (_r0 *SpanSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_time(ss._inner) - return &SpanSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SpanSet{_inner: _cret}, nil } // TsequencesetTimestamptzN wraps MEOS C function tsequenceset_timestamptz_n. -func TsequencesetTimestamptzN(ss *TSequenceSet, n int) (bool, int64) { +func TsequencesetTimestamptzN(ss *TSequenceSet, n int) (_r0 bool, _r1 int64, _err error) { var _out_result C.TimestampTz + C.meos_errno_reset() _cret := C.tsequenceset_timestamptz_n(ss._inner, C.int(n), &_out_result) - return bool(_cret), int64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), int64(_out_result), nil } // TsequencesetTimestamps wraps MEOS C function tsequenceset_timestamps. -func TsequencesetTimestamps(ss *TSequenceSet, count unsafe.Pointer) unsafe.Pointer { +func TsequencesetTimestamps(ss *TSequenceSet, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_timestamps(ss._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TemporalRestart wraps MEOS C function temporal_restart. -func TemporalRestart(temp *Temporal, count int) { +func TemporalRestart(temp *Temporal, count int) (_err error) { + C.meos_errno_reset() C.temporal_restart(temp._inner, C.int(count)) + if _err = meosError(); _err != nil { + return + } + return nil } // TemporalTsequence wraps MEOS C function temporal_tsequence. -func TemporalTsequence(temp *Temporal, interp Interpolation) *TSequence { +func TemporalTsequence(temp *Temporal, interp Interpolation) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.temporal_tsequence(temp._inner, C.interpType(interp)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TemporalTsequenceset wraps MEOS C function temporal_tsequenceset. -func TemporalTsequenceset(temp *Temporal, interp Interpolation) *TSequenceSet { +func TemporalTsequenceset(temp *Temporal, interp Interpolation) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.temporal_tsequenceset(temp._inner, C.interpType(interp)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TinstantShiftTime wraps MEOS C function tinstant_shift_time. -func TinstantShiftTime(inst *TInstant, interv *Interval) *TInstant { +func TinstantShiftTime(inst *TInstant, interv *Interval) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tinstant_shift_time(inst._inner, interv._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TinstantAsTsequence wraps MEOS C function tinstant_as_tsequence. -func TinstantAsTsequence(inst *TInstant, interp Interpolation) *TSequence { +func TinstantAsTsequence(inst *TInstant, interp Interpolation) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tinstant_as_tsequence(inst._inner, C.interpType(interp)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TinstantToTsequenceFree wraps MEOS C function tinstant_to_tsequence_free. -func TinstantToTsequenceFree(inst *TInstant, interp Interpolation) *TSequence { +func TinstantToTsequenceFree(inst *TInstant, interp Interpolation) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tinstant_to_tsequence_free(inst._inner, C.interpType(interp)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TinstantAsTsequenceset wraps MEOS C function tinstant_as_tsequenceset. -func TinstantAsTsequenceset(inst *TInstant, interp Interpolation) *TSequenceSet { +func TinstantAsTsequenceset(inst *TInstant, interp Interpolation) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tinstant_as_tsequenceset(inst._inner, C.interpType(interp)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequenceRestart wraps MEOS C function tsequence_restart. -func TsequenceRestart(seq *TSequence, count int) { +func TsequenceRestart(seq *TSequence, count int) (_err error) { + C.meos_errno_reset() C.tsequence_restart(seq._inner, C.int(count)) + if _err = meosError(); _err != nil { + return + } + return nil } // TsequenceSetInterp wraps MEOS C function tsequence_set_interp. -func TsequenceSetInterp(seq *TSequence, interp Interpolation) *Temporal { +func TsequenceSetInterp(seq *TSequence, interp Interpolation) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tsequence_set_interp(seq._inner, C.interpType(interp)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TsequenceShiftScaleTime wraps MEOS C function tsequence_shift_scale_time. -func TsequenceShiftScaleTime(seq *TSequence, shift *Interval, duration *Interval) *TSequence { +func TsequenceShiftScaleTime(seq *TSequence, shift *Interval, duration *Interval) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tsequence_shift_scale_time(seq._inner, shift._inner, duration._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TsequenceSubseq wraps MEOS C function tsequence_subseq. -func TsequenceSubseq(seq *TSequence, from int, to int, lower_inc bool, upper_inc bool) *TSequence { +func TsequenceSubseq(seq *TSequence, from int, to int, lower_inc bool, upper_inc bool) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tsequence_subseq(seq._inner, C.int(from), C.int(to), C.bool(lower_inc), C.bool(upper_inc)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TsequenceAsTinstant wraps MEOS C function tsequence_as_tinstant. -func TsequenceAsTinstant(seq *TSequence) *TInstant { +func TsequenceAsTinstant(seq *TSequence) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tsequence_as_tinstant(seq._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TsequenceAsTsequenceset wraps MEOS C function tsequence_as_tsequenceset. -func TsequenceAsTsequenceset(seq *TSequence) *TSequenceSet { +func TsequenceAsTsequenceset(seq *TSequence) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequence_as_tsequenceset(seq._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequenceToTsequencesetFree wraps MEOS C function tsequence_to_tsequenceset_free. -func TsequenceToTsequencesetFree(seq *TSequence) *TSequenceSet { +func TsequenceToTsequencesetFree(seq *TSequence) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequence_to_tsequenceset_free(seq._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequenceToTsequencesetInterp wraps MEOS C function tsequence_to_tsequenceset_interp. -func TsequenceToTsequencesetInterp(seq *TSequence, interp Interpolation) *TSequenceSet { +func TsequenceToTsequencesetInterp(seq *TSequence, interp Interpolation) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequence_to_tsequenceset_interp(seq._inner, C.interpType(interp)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequencesetRestart wraps MEOS C function tsequenceset_restart. -func TsequencesetRestart(ss *TSequenceSet, count int) { +func TsequencesetRestart(ss *TSequenceSet, count int) (_err error) { + C.meos_errno_reset() C.tsequenceset_restart(ss._inner, C.int(count)) + if _err = meosError(); _err != nil { + return + } + return nil } // TsequencesetSetInterp wraps MEOS C function tsequenceset_set_interp. -func TsequencesetSetInterp(ss *TSequenceSet, interp Interpolation) *Temporal { +func TsequencesetSetInterp(ss *TSequenceSet, interp Interpolation) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_set_interp(ss._inner, C.interpType(interp)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TsequencesetShiftScaleTime wraps MEOS C function tsequenceset_shift_scale_time. -func TsequencesetShiftScaleTime(ss *TSequenceSet, start *Interval, duration *Interval) *TSequenceSet { +func TsequencesetShiftScaleTime(ss *TSequenceSet, start *Interval, duration *Interval) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_shift_scale_time(ss._inner, start._inner, duration._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequencesetToDiscrete wraps MEOS C function tsequenceset_to_discrete. -func TsequencesetToDiscrete(ss *TSequenceSet) *TSequence { +func TsequencesetToDiscrete(ss *TSequenceSet) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_to_discrete(ss._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TsequencesetToLinear wraps MEOS C function tsequenceset_to_linear. -func TsequencesetToLinear(ss *TSequenceSet) *TSequenceSet { +func TsequencesetToLinear(ss *TSequenceSet) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_to_linear(ss._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequencesetToStep wraps MEOS C function tsequenceset_to_step. -func TsequencesetToStep(ss *TSequenceSet) *TSequenceSet { +func TsequencesetToStep(ss *TSequenceSet) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_to_step(ss._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequencesetAsTinstant wraps MEOS C function tsequenceset_as_tinstant. -func TsequencesetAsTinstant(ss *TSequenceSet) *TInstant { +func TsequencesetAsTinstant(ss *TSequenceSet) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_as_tinstant(ss._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TsequencesetAsTsequence wraps MEOS C function tsequenceset_as_tsequence. -func TsequencesetAsTsequence(ss *TSequenceSet) *TSequence { +func TsequencesetAsTsequence(ss *TSequenceSet) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_as_tsequence(ss._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TinstantMerge wraps MEOS C function tinstant_merge. -func TinstantMerge(inst1 *TInstant, inst2 *TInstant) *Temporal { +func TinstantMerge(inst1 *TInstant, inst2 *TInstant) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tinstant_merge(inst1._inner, inst2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TinstantMergeArray wraps MEOS C function tinstant_merge_array. -func TinstantMergeArray(instants unsafe.Pointer, count int) *Temporal { +func TinstantMergeArray(instants unsafe.Pointer, count int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tinstant_merge_array((**C.TInstant)(unsafe.Pointer(instants)), C.int(count)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TsequenceAppendTinstant wraps MEOS C function tsequence_append_tinstant. -func TsequenceAppendTinstant(seq *TSequence, inst *TInstant, maxdist float64, maxt *Interval, expand bool) *Temporal { +func TsequenceAppendTinstant(seq *TSequence, inst *TInstant, maxdist float64, maxt *Interval, expand bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tsequence_append_tinstant(seq._inner, inst._inner, C.double(maxdist), maxt._inner, C.bool(expand)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TsequenceAppendTsequence wraps MEOS C function tsequence_append_tsequence. -func TsequenceAppendTsequence(seq1 *TSequence, seq2 *TSequence, expand bool) *Temporal { +func TsequenceAppendTsequence(seq1 *TSequence, seq2 *TSequence, expand bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tsequence_append_tsequence(seq1._inner, seq2._inner, C.bool(expand)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TsequenceDeleteTimestamptz wraps MEOS C function tsequence_delete_timestamptz. -func TsequenceDeleteTimestamptz(seq *TSequence, t int64, connect bool) *Temporal { +func TsequenceDeleteTimestamptz(seq *TSequence, t int64, connect bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tsequence_delete_timestamptz(seq._inner, C.TimestampTz(t), C.bool(connect)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TsequenceDeleteTstzset wraps MEOS C function tsequence_delete_tstzset. -func TsequenceDeleteTstzset(seq *TSequence, s *Set, connect bool) *Temporal { +func TsequenceDeleteTstzset(seq *TSequence, s *Set, connect bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tsequence_delete_tstzset(seq._inner, s._inner, C.bool(connect)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TsequenceDeleteTstzspan wraps MEOS C function tsequence_delete_tstzspan. -func TsequenceDeleteTstzspan(seq *TSequence, s *Span, connect bool) *Temporal { +func TsequenceDeleteTstzspan(seq *TSequence, s *Span, connect bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tsequence_delete_tstzspan(seq._inner, s._inner, C.bool(connect)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TsequenceDeleteTstzspanset wraps MEOS C function tsequence_delete_tstzspanset. -func TsequenceDeleteTstzspanset(seq *TSequence, ss *SpanSet, connect bool) *Temporal { +func TsequenceDeleteTstzspanset(seq *TSequence, ss *SpanSet, connect bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tsequence_delete_tstzspanset(seq._inner, ss._inner, C.bool(connect)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TsequenceInsert wraps MEOS C function tsequence_insert. -func TsequenceInsert(seq1 *TSequence, seq2 *TSequence, connect bool) *Temporal { +func TsequenceInsert(seq1 *TSequence, seq2 *TSequence, connect bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tsequence_insert(seq1._inner, seq2._inner, C.bool(connect)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TsequenceMerge wraps MEOS C function tsequence_merge. -func TsequenceMerge(seq1 *TSequence, seq2 *TSequence) *Temporal { +func TsequenceMerge(seq1 *TSequence, seq2 *TSequence) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tsequence_merge(seq1._inner, seq2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TsequenceMergeArray wraps MEOS C function tsequence_merge_array. -func TsequenceMergeArray(sequences unsafe.Pointer, count int) *Temporal { +func TsequenceMergeArray(sequences unsafe.Pointer, count int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tsequence_merge_array((**C.TSequence)(unsafe.Pointer(sequences)), C.int(count)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TsequencesetAppendTinstant wraps MEOS C function tsequenceset_append_tinstant. -func TsequencesetAppendTinstant(ss *TSequenceSet, inst *TInstant, maxdist float64, maxt *Interval, expand bool) *TSequenceSet { +func TsequencesetAppendTinstant(ss *TSequenceSet, inst *TInstant, maxdist float64, maxt *Interval, expand bool) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_append_tinstant(ss._inner, inst._inner, C.double(maxdist), maxt._inner, C.bool(expand)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequencesetAppendTsequence wraps MEOS C function tsequenceset_append_tsequence. -func TsequencesetAppendTsequence(ss *TSequenceSet, seq *TSequence, expand bool) *TSequenceSet { +func TsequencesetAppendTsequence(ss *TSequenceSet, seq *TSequence, expand bool) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_append_tsequence(ss._inner, seq._inner, C.bool(expand)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequencesetDeleteTimestamptz wraps MEOS C function tsequenceset_delete_timestamptz. -func TsequencesetDeleteTimestamptz(ss *TSequenceSet, t int64) *TSequenceSet { +func TsequencesetDeleteTimestamptz(ss *TSequenceSet, t int64) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_delete_timestamptz(ss._inner, C.TimestampTz(t)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequencesetDeleteTstzset wraps MEOS C function tsequenceset_delete_tstzset. -func TsequencesetDeleteTstzset(ss *TSequenceSet, s *Set) *TSequenceSet { +func TsequencesetDeleteTstzset(ss *TSequenceSet, s *Set) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_delete_tstzset(ss._inner, s._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequencesetDeleteTstzspan wraps MEOS C function tsequenceset_delete_tstzspan. -func TsequencesetDeleteTstzspan(ss *TSequenceSet, s *Span) *TSequenceSet { +func TsequencesetDeleteTstzspan(ss *TSequenceSet, s *Span) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_delete_tstzspan(ss._inner, s._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequencesetDeleteTstzspanset wraps MEOS C function tsequenceset_delete_tstzspanset. -func TsequencesetDeleteTstzspanset(ss *TSequenceSet, ps *SpanSet) *TSequenceSet { +func TsequencesetDeleteTstzspanset(ss *TSequenceSet, ps *SpanSet) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_delete_tstzspanset(ss._inner, ps._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequencesetInsert wraps MEOS C function tsequenceset_insert. -func TsequencesetInsert(ss1 *TSequenceSet, ss2 *TSequenceSet) *TSequenceSet { +func TsequencesetInsert(ss1 *TSequenceSet, ss2 *TSequenceSet) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_insert(ss1._inner, ss2._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequencesetMerge wraps MEOS C function tsequenceset_merge. -func TsequencesetMerge(ss1 *TSequenceSet, ss2 *TSequenceSet) *TSequenceSet { +func TsequencesetMerge(ss1 *TSequenceSet, ss2 *TSequenceSet) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_merge(ss1._inner, ss2._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequencesetMergeArray wraps MEOS C function tsequenceset_merge_array. -func TsequencesetMergeArray(seqsets unsafe.Pointer, count int) *TSequenceSet { +func TsequencesetMergeArray(seqsets unsafe.Pointer, count int) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_merge_array((**C.TSequenceSet)(unsafe.Pointer(seqsets)), C.int(count)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequenceExpandBbox wraps MEOS C function tsequence_expand_bbox. -func TsequenceExpandBbox(seq *TSequence, inst *TInstant) { +func TsequenceExpandBbox(seq *TSequence, inst *TInstant) (_err error) { + C.meos_errno_reset() C.tsequence_expand_bbox(seq._inner, inst._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // TsequenceSetBbox wraps MEOS C function tsequence_set_bbox. -func TsequenceSetBbox(seq *TSequence, box unsafe.Pointer) { +func TsequenceSetBbox(seq *TSequence, box unsafe.Pointer) (_err error) { + C.meos_errno_reset() C.tsequence_set_bbox(seq._inner, unsafe.Pointer(box)) + if _err = meosError(); _err != nil { + return + } + return nil } // TsequencesetExpandBbox wraps MEOS C function tsequenceset_expand_bbox. -func TsequencesetExpandBbox(ss *TSequenceSet, seq *TSequence) { +func TsequencesetExpandBbox(ss *TSequenceSet, seq *TSequence) (_err error) { + C.meos_errno_reset() C.tsequenceset_expand_bbox(ss._inner, seq._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // TsequencesetSetBbox wraps MEOS C function tsequenceset_set_bbox. -func TsequencesetSetBbox(ss *TSequenceSet, box unsafe.Pointer) { +func TsequencesetSetBbox(ss *TSequenceSet, box unsafe.Pointer) (_err error) { + C.meos_errno_reset() C.tsequenceset_set_bbox(ss._inner, unsafe.Pointer(box)) + if _err = meosError(); _err != nil { + return + } + return nil } // TcontseqAfterTimestamptz wraps MEOS C function tcontseq_after_timestamptz. -func TcontseqAfterTimestamptz(seq *TSequence, t int64, strict bool) *TSequence { +func TcontseqAfterTimestamptz(seq *TSequence, t int64, strict bool) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tcontseq_after_timestamptz(seq._inner, C.TimestampTz(t), C.bool(strict)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TcontseqBeforeTimestamptz wraps MEOS C function tcontseq_before_timestamptz. -func TcontseqBeforeTimestamptz(seq *TSequence, t int64, strict bool) *TSequence { +func TcontseqBeforeTimestamptz(seq *TSequence, t int64, strict bool) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tcontseq_before_timestamptz(seq._inner, C.TimestampTz(t), C.bool(strict)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TcontseqRestrictMinmax wraps MEOS C function tcontseq_restrict_minmax. -func TcontseqRestrictMinmax(seq *TSequence, min bool, atfunc bool) *TSequenceSet { +func TcontseqRestrictMinmax(seq *TSequence, min bool, atfunc bool) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tcontseq_restrict_minmax(seq._inner, C.bool(min), C.bool(atfunc)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TdiscseqAfterTimestamptz wraps MEOS C function tdiscseq_after_timestamptz. -func TdiscseqAfterTimestamptz(seq *TSequence, t int64, strict bool) *TSequence { +func TdiscseqAfterTimestamptz(seq *TSequence, t int64, strict bool) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tdiscseq_after_timestamptz(seq._inner, C.TimestampTz(t), C.bool(strict)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TdiscseqBeforeTimestamptz wraps MEOS C function tdiscseq_before_timestamptz. -func TdiscseqBeforeTimestamptz(seq *TSequence, t int64, strict bool) *TSequence { +func TdiscseqBeforeTimestamptz(seq *TSequence, t int64, strict bool) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tdiscseq_before_timestamptz(seq._inner, C.TimestampTz(t), C.bool(strict)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TdiscseqRestrictMinmax wraps MEOS C function tdiscseq_restrict_minmax. -func TdiscseqRestrictMinmax(seq *TSequence, min bool, atfunc bool) *TSequence { +func TdiscseqRestrictMinmax(seq *TSequence, min bool, atfunc bool) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tdiscseq_restrict_minmax(seq._inner, C.bool(min), C.bool(atfunc)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TemporalBboxRestrictSet wraps MEOS C function temporal_bbox_restrict_set. -func TemporalBboxRestrictSet(temp *Temporal, set *Set) bool { +func TemporalBboxRestrictSet(temp *Temporal, set *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.temporal_bbox_restrict_set(temp._inner, set._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TemporalRestrictMinmax wraps MEOS C function temporal_restrict_minmax. -func TemporalRestrictMinmax(temp *Temporal, min bool, atfunc bool) *Temporal { +func TemporalRestrictMinmax(temp *Temporal, min bool, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_restrict_minmax(temp._inner, C.bool(min), C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalRestrictTimestamptz wraps MEOS C function temporal_restrict_timestamptz. -func TemporalRestrictTimestamptz(temp *Temporal, t int64, atfunc bool) *Temporal { +func TemporalRestrictTimestamptz(temp *Temporal, t int64, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_restrict_timestamptz(temp._inner, C.TimestampTz(t), C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalRestrictTstzset wraps MEOS C function temporal_restrict_tstzset. -func TemporalRestrictTstzset(temp *Temporal, s *Set, atfunc bool) *Temporal { +func TemporalRestrictTstzset(temp *Temporal, s *Set, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_restrict_tstzset(temp._inner, s._inner, C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalRestrictTstzspan wraps MEOS C function temporal_restrict_tstzspan. -func TemporalRestrictTstzspan(temp *Temporal, s *Span, atfunc bool) *Temporal { +func TemporalRestrictTstzspan(temp *Temporal, s *Span, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_restrict_tstzspan(temp._inner, s._inner, C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalRestrictTstzspanset wraps MEOS C function temporal_restrict_tstzspanset. -func TemporalRestrictTstzspanset(temp *Temporal, ss *SpanSet, atfunc bool) *Temporal { +func TemporalRestrictTstzspanset(temp *Temporal, ss *SpanSet, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_restrict_tstzspanset(temp._inner, ss._inner, C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalRestrictValues wraps MEOS C function temporal_restrict_values. -func TemporalRestrictValues(temp *Temporal, set *Set, atfunc bool) *Temporal { +func TemporalRestrictValues(temp *Temporal, set *Set, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_restrict_values(temp._inner, set._inner, C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TinstantAfterTimestamptz wraps MEOS C function tinstant_after_timestamptz. -func TinstantAfterTimestamptz(inst *TInstant, t int64, strict bool) *TInstant { +func TinstantAfterTimestamptz(inst *TInstant, t int64, strict bool) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tinstant_after_timestamptz(inst._inner, C.TimestampTz(t), C.bool(strict)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TinstantBeforeTimestamptz wraps MEOS C function tinstant_before_timestamptz. -func TinstantBeforeTimestamptz(inst *TInstant, t int64, strict bool) *TInstant { +func TinstantBeforeTimestamptz(inst *TInstant, t int64, strict bool) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tinstant_before_timestamptz(inst._inner, C.TimestampTz(t), C.bool(strict)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TinstantRestrictTstzspan wraps MEOS C function tinstant_restrict_tstzspan. -func TinstantRestrictTstzspan(inst *TInstant, period *Span, atfunc bool) *TInstant { +func TinstantRestrictTstzspan(inst *TInstant, period *Span, atfunc bool) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tinstant_restrict_tstzspan(inst._inner, period._inner, C.bool(atfunc)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TinstantRestrictTstzspanset wraps MEOS C function tinstant_restrict_tstzspanset. -func TinstantRestrictTstzspanset(inst *TInstant, ss *SpanSet, atfunc bool) *TInstant { +func TinstantRestrictTstzspanset(inst *TInstant, ss *SpanSet, atfunc bool) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tinstant_restrict_tstzspanset(inst._inner, ss._inner, C.bool(atfunc)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TinstantRestrictTimestamptz wraps MEOS C function tinstant_restrict_timestamptz. -func TinstantRestrictTimestamptz(inst *TInstant, t int64, atfunc bool) *TInstant { +func TinstantRestrictTimestamptz(inst *TInstant, t int64, atfunc bool) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tinstant_restrict_timestamptz(inst._inner, C.TimestampTz(t), C.bool(atfunc)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TinstantRestrictTstzset wraps MEOS C function tinstant_restrict_tstzset. -func TinstantRestrictTstzset(inst *TInstant, s *Set, atfunc bool) *TInstant { +func TinstantRestrictTstzset(inst *TInstant, s *Set, atfunc bool) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tinstant_restrict_tstzset(inst._inner, s._inner, C.bool(atfunc)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TinstantRestrictValues wraps MEOS C function tinstant_restrict_values. -func TinstantRestrictValues(inst *TInstant, set *Set, atfunc bool) *TInstant { +func TinstantRestrictValues(inst *TInstant, set *Set, atfunc bool) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tinstant_restrict_values(inst._inner, set._inner, C.bool(atfunc)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TnumberRestrictSpan wraps MEOS C function tnumber_restrict_span. -func TnumberRestrictSpan(temp *Temporal, span *Span, atfunc bool) *Temporal { +func TnumberRestrictSpan(temp *Temporal, span *Span, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnumber_restrict_span(temp._inner, span._inner, C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnumberRestrictSpanset wraps MEOS C function tnumber_restrict_spanset. -func TnumberRestrictSpanset(temp *Temporal, ss *SpanSet, atfunc bool) *Temporal { +func TnumberRestrictSpanset(temp *Temporal, ss *SpanSet, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnumber_restrict_spanset(temp._inner, ss._inner, C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnumberinstRestrictSpan wraps MEOS C function tnumberinst_restrict_span. -func TnumberinstRestrictSpan(inst *TInstant, span *Span, atfunc bool) *TInstant { +func TnumberinstRestrictSpan(inst *TInstant, span *Span, atfunc bool) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tnumberinst_restrict_span(inst._inner, span._inner, C.bool(atfunc)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TnumberinstRestrictSpanset wraps MEOS C function tnumberinst_restrict_spanset. -func TnumberinstRestrictSpanset(inst *TInstant, ss *SpanSet, atfunc bool) *TInstant { +func TnumberinstRestrictSpanset(inst *TInstant, ss *SpanSet, atfunc bool) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tnumberinst_restrict_spanset(inst._inner, ss._inner, C.bool(atfunc)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TnumberseqsetRestrictSpan wraps MEOS C function tnumberseqset_restrict_span. -func TnumberseqsetRestrictSpan(ss *TSequenceSet, span *Span, atfunc bool) *TSequenceSet { +func TnumberseqsetRestrictSpan(ss *TSequenceSet, span *Span, atfunc bool) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tnumberseqset_restrict_span(ss._inner, span._inner, C.bool(atfunc)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TnumberseqsetRestrictSpanset wraps MEOS C function tnumberseqset_restrict_spanset. -func TnumberseqsetRestrictSpanset(ss *TSequenceSet, spanset *SpanSet, atfunc bool) *TSequenceSet { +func TnumberseqsetRestrictSpanset(ss *TSequenceSet, spanset *SpanSet, atfunc bool) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tnumberseqset_restrict_spanset(ss._inner, spanset._inner, C.bool(atfunc)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequenceAtTimestamptz wraps MEOS C function tsequence_at_timestamptz. -func TsequenceAtTimestamptz(seq *TSequence, t int64) *TInstant { +func TsequenceAtTimestamptz(seq *TSequence, t int64) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tsequence_at_timestamptz(seq._inner, C.TimestampTz(t)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TsequenceRestrictTstzspan wraps MEOS C function tsequence_restrict_tstzspan. -func TsequenceRestrictTstzspan(seq *TSequence, s *Span, atfunc bool) *Temporal { +func TsequenceRestrictTstzspan(seq *TSequence, s *Span, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tsequence_restrict_tstzspan(seq._inner, s._inner, C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TsequenceRestrictTstzspanset wraps MEOS C function tsequence_restrict_tstzspanset. -func TsequenceRestrictTstzspanset(seq *TSequence, ss *SpanSet, atfunc bool) *Temporal { +func TsequenceRestrictTstzspanset(seq *TSequence, ss *SpanSet, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tsequence_restrict_tstzspanset(seq._inner, ss._inner, C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TsequencesetAfterTimestamptz wraps MEOS C function tsequenceset_after_timestamptz. -func TsequencesetAfterTimestamptz(ss *TSequenceSet, t int64, strict bool) *TSequenceSet { +func TsequencesetAfterTimestamptz(ss *TSequenceSet, t int64, strict bool) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_after_timestamptz(ss._inner, C.TimestampTz(t), C.bool(strict)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequencesetBeforeTimestamptz wraps MEOS C function tsequenceset_before_timestamptz. -func TsequencesetBeforeTimestamptz(ss *TSequenceSet, t int64, strict bool) *TSequenceSet { +func TsequencesetBeforeTimestamptz(ss *TSequenceSet, t int64, strict bool) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_before_timestamptz(ss._inner, C.TimestampTz(t), C.bool(strict)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequencesetRestrictMinmax wraps MEOS C function tsequenceset_restrict_minmax. -func TsequencesetRestrictMinmax(ss *TSequenceSet, min bool, atfunc bool) *TSequenceSet { +func TsequencesetRestrictMinmax(ss *TSequenceSet, min bool, atfunc bool) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_restrict_minmax(ss._inner, C.bool(min), C.bool(atfunc)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequencesetRestrictTstzspan wraps MEOS C function tsequenceset_restrict_tstzspan. -func TsequencesetRestrictTstzspan(ss *TSequenceSet, s *Span, atfunc bool) *TSequenceSet { +func TsequencesetRestrictTstzspan(ss *TSequenceSet, s *Span, atfunc bool) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_restrict_tstzspan(ss._inner, s._inner, C.bool(atfunc)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequencesetRestrictTstzspanset wraps MEOS C function tsequenceset_restrict_tstzspanset. -func TsequencesetRestrictTstzspanset(ss *TSequenceSet, ps *SpanSet, atfunc bool) *TSequenceSet { +func TsequencesetRestrictTstzspanset(ss *TSequenceSet, ps *SpanSet, atfunc bool) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_restrict_tstzspanset(ss._inner, ps._inner, C.bool(atfunc)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TsequencesetRestrictTimestamptz wraps MEOS C function tsequenceset_restrict_timestamptz. -func TsequencesetRestrictTimestamptz(ss *TSequenceSet, t int64, atfunc bool) *Temporal { +func TsequencesetRestrictTimestamptz(ss *TSequenceSet, t int64, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_restrict_timestamptz(ss._inner, C.TimestampTz(t), C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TsequencesetRestrictTstzset wraps MEOS C function tsequenceset_restrict_tstzset. -func TsequencesetRestrictTstzset(ss *TSequenceSet, s *Set, atfunc bool) *Temporal { +func TsequencesetRestrictTstzset(ss *TSequenceSet, s *Set, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_restrict_tstzset(ss._inner, s._inner, C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TsequencesetRestrictValues wraps MEOS C function tsequenceset_restrict_values. -func TsequencesetRestrictValues(ss *TSequenceSet, s *Set, atfunc bool) *TSequenceSet { +func TsequencesetRestrictValues(ss *TSequenceSet, s *Set, atfunc bool) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_restrict_values(ss._inner, s._inner, C.bool(atfunc)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TinstantCmp wraps MEOS C function tinstant_cmp. -func TinstantCmp(inst1 *TInstant, inst2 *TInstant) int { +func TinstantCmp(inst1 *TInstant, inst2 *TInstant) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.tinstant_cmp(inst1._inner, inst2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TinstantEq wraps MEOS C function tinstant_eq. -func TinstantEq(inst1 *TInstant, inst2 *TInstant) bool { +func TinstantEq(inst1 *TInstant, inst2 *TInstant) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tinstant_eq(inst1._inner, inst2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TsequenceCmp wraps MEOS C function tsequence_cmp. -func TsequenceCmp(seq1 *TSequence, seq2 *TSequence) int { +func TsequenceCmp(seq1 *TSequence, seq2 *TSequence) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.tsequence_cmp(seq1._inner, seq2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TsequenceEq wraps MEOS C function tsequence_eq. -func TsequenceEq(seq1 *TSequence, seq2 *TSequence) bool { +func TsequenceEq(seq1 *TSequence, seq2 *TSequence) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tsequence_eq(seq1._inner, seq2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TsequencesetCmp wraps MEOS C function tsequenceset_cmp. -func TsequencesetCmp(ss1 *TSequenceSet, ss2 *TSequenceSet) int { +func TsequencesetCmp(ss1 *TSequenceSet, ss2 *TSequenceSet) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_cmp(ss1._inner, ss2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TsequencesetEq wraps MEOS C function tsequenceset_eq. -func TsequencesetEq(ss1 *TSequenceSet, ss2 *TSequenceSet) bool { +func TsequencesetEq(ss1 *TSequenceSet, ss2 *TSequenceSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_eq(ss1._inner, ss2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TnumberinstAbs wraps MEOS C function tnumberinst_abs. -func TnumberinstAbs(inst *TInstant) *TInstant { +func TnumberinstAbs(inst *TInstant) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tnumberinst_abs(inst._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TnumberinstDistance wraps MEOS C function tnumberinst_distance. -func TnumberinstDistance(inst1 *TInstant, inst2 *TInstant) float64 { +func TnumberinstDistance(inst1 *TInstant, inst2 *TInstant) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.tnumberinst_distance(inst1._inner, inst2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TnumberseqAbs wraps MEOS C function tnumberseq_abs. -func TnumberseqAbs(seq *TSequence) *TSequence { +func TnumberseqAbs(seq *TSequence) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tnumberseq_abs(seq._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TnumberseqAngularDifference wraps MEOS C function tnumberseq_angular_difference. -func TnumberseqAngularDifference(seq *TSequence) *TSequence { +func TnumberseqAngularDifference(seq *TSequence) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tnumberseq_angular_difference(seq._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TnumberseqDeltaValue wraps MEOS C function tnumberseq_delta_value. -func TnumberseqDeltaValue(seq *TSequence) *TSequence { +func TnumberseqDeltaValue(seq *TSequence) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tnumberseq_delta_value(seq._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TnumberseqsetAbs wraps MEOS C function tnumberseqset_abs. -func TnumberseqsetAbs(ss *TSequenceSet) *TSequenceSet { +func TnumberseqsetAbs(ss *TSequenceSet) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tnumberseqset_abs(ss._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TnumberseqsetAngularDifference wraps MEOS C function tnumberseqset_angular_difference. -func TnumberseqsetAngularDifference(ss *TSequenceSet) *TSequence { +func TnumberseqsetAngularDifference(ss *TSequenceSet) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tnumberseqset_angular_difference(ss._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TnumberseqsetDeltaValue wraps MEOS C function tnumberseqset_delta_value. -func TnumberseqsetDeltaValue(ss *TSequenceSet) *TSequenceSet { +func TnumberseqsetDeltaValue(ss *TSequenceSet) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tnumberseqset_delta_value(ss._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TnumberseqIntegral wraps MEOS C function tnumberseq_integral. -func TnumberseqIntegral(seq *TSequence) float64 { +func TnumberseqIntegral(seq *TSequence) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.tnumberseq_integral(seq._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TnumberseqTwavg wraps MEOS C function tnumberseq_twavg. -func TnumberseqTwavg(seq *TSequence) float64 { +func TnumberseqTwavg(seq *TSequence) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.tnumberseq_twavg(seq._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TnumberseqsetIntegral wraps MEOS C function tnumberseqset_integral. -func TnumberseqsetIntegral(ss *TSequenceSet) float64 { +func TnumberseqsetIntegral(ss *TSequenceSet) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.tnumberseqset_integral(ss._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TnumberseqsetTwavg wraps MEOS C function tnumberseqset_twavg. -func TnumberseqsetTwavg(ss *TSequenceSet) float64 { +func TnumberseqsetTwavg(ss *TSequenceSet) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.tnumberseqset_twavg(ss._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TemporalCompact wraps MEOS C function temporal_compact. -func TemporalCompact(temp *Temporal) *Temporal { +func TemporalCompact(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_compact(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TsequenceCompact wraps MEOS C function tsequence_compact. -func TsequenceCompact(seq *TSequence) *TSequence { +func TsequenceCompact(seq *TSequence) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tsequence_compact(seq._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TsequencesetCompact wraps MEOS C function tsequenceset_compact. -func TsequencesetCompact(ss *TSequenceSet) *TSequenceSet { +func TsequencesetCompact(ss *TSequenceSet) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tsequenceset_compact(ss._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TemporalSkiplistMake wraps MEOS C function temporal_skiplist_make. -func TemporalSkiplistMake() *SkipList { +func TemporalSkiplistMake() (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.temporal_skiplist_make() - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // SkiplistMake wraps MEOS C function skiplist_make. -func SkiplistMake(key_size uint, value_size uint, comp_fn unsafe.Pointer, merge_fn unsafe.Pointer) *SkipList { +func SkiplistMake(key_size uint, value_size uint, comp_fn unsafe.Pointer, merge_fn unsafe.Pointer) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.skiplist_make(C.size_t(key_size), C.size_t(value_size), (*[0]byte)(comp_fn), (*[0]byte)(merge_fn)) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // SkiplistSearch wraps MEOS C function skiplist_search. -func SkiplistSearch(list *SkipList, key unsafe.Pointer, value unsafe.Pointer) int { +func SkiplistSearch(list *SkipList, key unsafe.Pointer, value unsafe.Pointer) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.skiplist_search(list._inner, unsafe.Pointer(key), unsafe.Pointer(value)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // SkiplistFree wraps MEOS C function skiplist_free. -func SkiplistFree(list *SkipList) { +func SkiplistFree(list *SkipList) (_err error) { + C.meos_errno_reset() C.skiplist_free(list._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // SkiplistSplice wraps MEOS C function skiplist_splice. -func SkiplistSplice(list *SkipList, keys unsafe.Pointer, values unsafe.Pointer, count int, func_ unsafe.Pointer, crossings bool, sktype SkipListType) { +func SkiplistSplice(list *SkipList, keys unsafe.Pointer, values unsafe.Pointer, count int, func_ unsafe.Pointer, crossings bool, sktype SkipListType) (_err error) { + C.meos_errno_reset() C.skiplist_splice(list._inner, (*unsafe.Pointer)(unsafe.Pointer(keys)), (*unsafe.Pointer)(unsafe.Pointer(values)), C.int(count), (*[0]byte)(func_), C.bool(crossings), C.SkipListType(sktype)) + if _err = meosError(); _err != nil { + return + } + return nil } // TemporalSkiplistSplice wraps MEOS C function temporal_skiplist_splice. -func TemporalSkiplistSplice(list *SkipList, values unsafe.Pointer, count int, func_ unsafe.Pointer, crossings bool) { +func TemporalSkiplistSplice(list *SkipList, values unsafe.Pointer, count int, func_ unsafe.Pointer, crossings bool) (_err error) { + C.meos_errno_reset() C.temporal_skiplist_splice(list._inner, (*unsafe.Pointer)(unsafe.Pointer(values)), C.int(count), (*[0]byte)(func_), C.bool(crossings)) + if _err = meosError(); _err != nil { + return + } + return nil } // SkiplistValues wraps MEOS C function skiplist_values. -func SkiplistValues(list *SkipList) unsafe.Pointer { +func SkiplistValues(list *SkipList) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.skiplist_values(list._inner) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // SkiplistKeysValues wraps MEOS C function skiplist_keys_values. -func SkiplistKeysValues(list *SkipList, values unsafe.Pointer) unsafe.Pointer { +func SkiplistKeysValues(list *SkipList, values unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.skiplist_keys_values(list._inner, (*unsafe.Pointer)(unsafe.Pointer(values))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TemporalAppTinstTransfn wraps MEOS C function temporal_app_tinst_transfn. -func TemporalAppTinstTransfn(state *Temporal, inst *TInstant, interp Interpolation, maxdist float64, maxt *Interval) *Temporal { +func TemporalAppTinstTransfn(state *Temporal, inst *TInstant, interp Interpolation, maxdist float64, maxt *Interval) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_app_tinst_transfn(state._inner, inst._inner, C.interpType(interp), C.double(maxdist), maxt._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TemporalAppTseqTransfn wraps MEOS C function temporal_app_tseq_transfn. -func TemporalAppTseqTransfn(state *Temporal, seq *TSequence) *Temporal { +func TemporalAppTseqTransfn(state *Temporal, seq *TSequence) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.temporal_app_tseq_transfn(state._inner, seq._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } diff --git a/functions/meos_meos_internal_geo.go b/functions/meos_meos_internal_geo.go index feef940..0f84396 100644 --- a/functions/meos_meos_internal_geo.go +++ b/functions/meos_meos_internal_geo.go @@ -86,576 +86,896 @@ import ( var _ = unsafe.Pointer(nil) // ProjGetContext wraps MEOS C function proj_get_context. -func ProjGetContext() *PJContext { +func ProjGetContext() (_r0 *PJContext, _err error) { + C.meos_errno_reset() _cret := C.proj_get_context() - return &PJContext{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &PJContext{_inner: _cret}, nil } // PointRound wraps MEOS C function point_round. -func PointRound(gs *Geom, maxdd int) *Geom { +func PointRound(gs *Geom, maxdd int) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.point_round(gs._inner, C.int(maxdd)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // GeoSetSRIDInt wraps MEOS C function geo_set_srid_int. -func GeoSetSRIDInt(gs *Geom, srid int32) { +func GeoSetSRIDInt(gs *Geom, srid int32) (_err error) { + C.meos_errno_reset() C.geo_set_srid_int(gs._inner, C.int32_t(srid)) + if _err = meosError(); _err != nil { + return + } + return 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) *STBox { +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 + C.meos_errno_reset() C.stbox_set(C.bool(hasx), C.bool(hasz), C.bool(geodetic), C.int32(srid), C.double(xmin), C.double(xmax), C.double(ymin), C.double(ymax), C.double(zmin), C.double(zmax), s._inner, &_out_result) - return &STBox{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: &_out_result}, nil } // GboxSetSTBOX wraps MEOS C function gbox_set_stbox. -func GboxSetSTBOX(box *GBox, srid int32) *STBox { +func GboxSetSTBOX(box *GBox, srid int32) (_r0 *STBox, _err error) { var _out_result C.STBox + C.meos_errno_reset() C.gbox_set_stbox(box._inner, C.int32_t(srid), &_out_result) - return &STBox{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: &_out_result}, nil } // GeoSetSTBOX wraps MEOS C function geo_set_stbox. -func GeoSetSTBOX(gs *Geom) (bool, *STBox) { +func GeoSetSTBOX(gs *Geom) (_r0 bool, _r1 *STBox, _err error) { var _out_result C.STBox + C.meos_errno_reset() _cret := C.geo_set_stbox(gs._inner, &_out_result) - return bool(_cret), &STBox{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &STBox{_inner: &_out_result}, nil } // SpatialsetSetSTBOX wraps MEOS C function spatialset_set_stbox. -func SpatialsetSetSTBOX(set *Set) *STBox { +func SpatialsetSetSTBOX(set *Set) (_r0 *STBox, _err error) { var _out_result C.STBox + C.meos_errno_reset() C.spatialset_set_stbox(set._inner, &_out_result) - return &STBox{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: &_out_result}, nil } // STBOXSetBox3d wraps MEOS C function stbox_set_box3d. -func STBOXSetBox3d(box *STBox) *Box3D { +func STBOXSetBox3d(box *STBox) (_r0 *Box3D, _err error) { var _out_result C.BOX3D + C.meos_errno_reset() C.stbox_set_box3d(box._inner, &_out_result) - return &Box3D{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return &Box3D{_inner: &_out_result}, nil } // STBOXSetGbox wraps MEOS C function stbox_set_gbox. -func STBOXSetGbox(box *STBox) *GBox { +func STBOXSetGbox(box *STBox) (_r0 *GBox, _err error) { var _out_result C.GBOX + C.meos_errno_reset() C.stbox_set_gbox(box._inner, &_out_result) - return &GBox{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return &GBox{_inner: &_out_result}, nil } // TstzsetSetSTBOX wraps MEOS C function tstzset_set_stbox. -func TstzsetSetSTBOX(s *Set) *STBox { +func TstzsetSetSTBOX(s *Set) (_r0 *STBox, _err error) { var _out_result C.STBox + C.meos_errno_reset() C.tstzset_set_stbox(s._inner, &_out_result) - return &STBox{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: &_out_result}, nil } // TimestamptzSetSTBOX wraps MEOS C function timestamptz_set_stbox. -func TimestamptzSetSTBOX(t int64) *STBox { +func TimestamptzSetSTBOX(t int64) (_r0 *STBox, _err error) { var _out_result C.STBox + C.meos_errno_reset() C.timestamptz_set_stbox(C.TimestampTz(t), &_out_result) - return &STBox{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: &_out_result}, nil } // TstzspanSetSTBOX wraps MEOS C function tstzspan_set_stbox. -func TstzspanSetSTBOX(s *Span) *STBox { +func TstzspanSetSTBOX(s *Span) (_r0 *STBox, _err error) { var _out_result C.STBox + C.meos_errno_reset() C.tstzspan_set_stbox(s._inner, &_out_result) - return &STBox{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: &_out_result}, nil } // TstzspansetSetSTBOX wraps MEOS C function tstzspanset_set_stbox. -func TstzspansetSetSTBOX(s *SpanSet) *STBox { +func TstzspansetSetSTBOX(s *SpanSet) (_r0 *STBox, _err error) { var _out_result C.STBox + C.meos_errno_reset() C.tstzspanset_set_stbox(s._inner, &_out_result) - return &STBox{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: &_out_result}, nil } // STBOXExpand wraps MEOS C function stbox_expand. -func STBOXExpand(box1 *STBox, box2 *STBox) { +func STBOXExpand(box1 *STBox, box2 *STBox) (_err error) { + C.meos_errno_reset() C.stbox_expand(box1._inner, box2._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // STBOXExpandSpaceSet wraps MEOS C function stbox_expand_space_set. -func STBOXExpandSpaceSet(box *STBox, d float64) (bool, *STBox) { +func STBOXExpandSpaceSet(box *STBox, d float64) (_r0 bool, _r1 *STBox, _err error) { var _out_result C.STBox + C.meos_errno_reset() _cret := C.stbox_expand_space_set(box._inner, C.double(d), &_out_result) - return bool(_cret), &STBox{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &STBox{_inner: &_out_result}, nil } // InterSTBOXSTBOX wraps MEOS C function inter_stbox_stbox. -func InterSTBOXSTBOX(box1 *STBox, box2 *STBox) (bool, *STBox) { +func InterSTBOXSTBOX(box1 *STBox, box2 *STBox) (_r0 bool, _r1 *STBox, _err error) { var _out_result C.STBox + C.meos_errno_reset() _cret := C.inter_stbox_stbox(box1._inner, box2._inner, &_out_result) - return bool(_cret), &STBox{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &STBox{_inner: &_out_result}, nil } // TgeogpointinstIn wraps MEOS C function tgeogpointinst_in. -func TgeogpointinstIn(str string) *TInstant { +func TgeogpointinstIn(str string) (_r0 *TInstant, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tgeogpointinst_in(_c_str) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TgeogpointseqIn wraps MEOS C function tgeogpointseq_in. -func TgeogpointseqIn(str string, interp Interpolation) *TSequence { +func TgeogpointseqIn(str string, interp Interpolation) (_r0 *TSequence, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tgeogpointseq_in(_c_str, C.interpType(interp)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TgeogpointseqsetIn wraps MEOS C function tgeogpointseqset_in. -func TgeogpointseqsetIn(str string) *TSequenceSet { +func TgeogpointseqsetIn(str string) (_r0 *TSequenceSet, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tgeogpointseqset_in(_c_str) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TgeompointinstIn wraps MEOS C function tgeompointinst_in. -func TgeompointinstIn(str string) *TInstant { +func TgeompointinstIn(str string) (_r0 *TInstant, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tgeompointinst_in(_c_str) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TgeompointseqIn wraps MEOS C function tgeompointseq_in. -func TgeompointseqIn(str string, interp Interpolation) *TSequence { +func TgeompointseqIn(str string, interp Interpolation) (_r0 *TSequence, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tgeompointseq_in(_c_str, C.interpType(interp)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TgeompointseqsetIn wraps MEOS C function tgeompointseqset_in. -func TgeompointseqsetIn(str string) *TSequenceSet { +func TgeompointseqsetIn(str string) (_r0 *TSequenceSet, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tgeompointseqset_in(_c_str) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TgeographyinstIn wraps MEOS C function tgeographyinst_in. -func TgeographyinstIn(str string) *TInstant { +func TgeographyinstIn(str string) (_r0 *TInstant, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tgeographyinst_in(_c_str) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TgeographyseqIn wraps MEOS C function tgeographyseq_in. -func TgeographyseqIn(str string, interp Interpolation) *TSequence { +func TgeographyseqIn(str string, interp Interpolation) (_r0 *TSequence, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tgeographyseq_in(_c_str, C.interpType(interp)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TgeographyseqsetIn wraps MEOS C function tgeographyseqset_in. -func TgeographyseqsetIn(str string) *TSequenceSet { +func TgeographyseqsetIn(str string) (_r0 *TSequenceSet, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tgeographyseqset_in(_c_str) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TgeometryinstIn wraps MEOS C function tgeometryinst_in. -func TgeometryinstIn(str string) *TInstant { +func TgeometryinstIn(str string) (_r0 *TInstant, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tgeometryinst_in(_c_str) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TgeometryseqIn wraps MEOS C function tgeometryseq_in. -func TgeometryseqIn(str string, interp Interpolation) *TSequence { +func TgeometryseqIn(str string, interp Interpolation) (_r0 *TSequence, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tgeometryseq_in(_c_str, C.interpType(interp)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TgeometryseqsetIn wraps MEOS C function tgeometryseqset_in. -func TgeometryseqsetIn(str string) *TSequenceSet { +func TgeometryseqsetIn(str string) (_r0 *TSequenceSet, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tgeometryseqset_in(_c_str) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TspatialSetSTBOX wraps MEOS C function tspatial_set_stbox. -func TspatialSetSTBOX(temp *Temporal) *STBox { +func TspatialSetSTBOX(temp *Temporal) (_r0 *STBox, _err error) { var _out_result C.STBox + C.meos_errno_reset() C.tspatial_set_stbox(temp._inner, &_out_result) - return &STBox{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: &_out_result}, nil } // TspatialseqSetSTBOX wraps MEOS C function tspatialseq_set_stbox. -func TspatialseqSetSTBOX(seq *TSequence, box *STBox) { +func TspatialseqSetSTBOX(seq *TSequence, box *STBox) (_err error) { + C.meos_errno_reset() C.tspatialseq_set_stbox(seq._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // TspatialseqsetSetSTBOX wraps MEOS C function tspatialseqset_set_stbox. -func TspatialseqsetSetSTBOX(ss *TSequenceSet, box *STBox) { +func TspatialseqsetSetSTBOX(ss *TSequenceSet, box *STBox) (_err error) { + C.meos_errno_reset() C.tspatialseqset_set_stbox(ss._inner, box._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // TgeoRestrictElevation wraps MEOS C function tgeo_restrict_elevation. -func TgeoRestrictElevation(temp *Temporal, s *Span, atfunc bool) *Temporal { +func TgeoRestrictElevation(temp *Temporal, s *Span, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeo_restrict_elevation(temp._inner, s._inner, C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeoRestrictGeom wraps MEOS C function tgeo_restrict_geom. -func TgeoRestrictGeom(temp *Temporal, gs *Geom, atfunc bool) *Temporal { +func TgeoRestrictGeom(temp *Temporal, gs *Geom, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeo_restrict_geom(temp._inner, gs._inner, C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeoRestrictSTBOX wraps MEOS C function tgeo_restrict_stbox. -func TgeoRestrictSTBOX(temp *Temporal, box *STBox, border_inc bool, atfunc bool) *Temporal { +func TgeoRestrictSTBOX(temp *Temporal, box *STBox, border_inc bool, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeo_restrict_stbox(temp._inner, box._inner, C.bool(border_inc), C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeoinstRestrictGeom wraps MEOS C function tgeoinst_restrict_geom. -func TgeoinstRestrictGeom(inst *TInstant, gs *Geom, atfunc bool) *TInstant { +func TgeoinstRestrictGeom(inst *TInstant, gs *Geom, atfunc bool) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tgeoinst_restrict_geom(inst._inner, gs._inner, C.bool(atfunc)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TgeoinstRestrictSTBOX wraps MEOS C function tgeoinst_restrict_stbox. -func TgeoinstRestrictSTBOX(inst *TInstant, box *STBox, border_inc bool, atfunc bool) *TInstant { +func TgeoinstRestrictSTBOX(inst *TInstant, box *STBox, border_inc bool, atfunc bool) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tgeoinst_restrict_stbox(inst._inner, box._inner, C.bool(border_inc), C.bool(atfunc)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TgeoseqRestrictGeom wraps MEOS C function tgeoseq_restrict_geom. -func TgeoseqRestrictGeom(seq *TSequence, gs *Geom, atfunc bool) *Temporal { +func TgeoseqRestrictGeom(seq *TSequence, gs *Geom, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeoseq_restrict_geom(seq._inner, gs._inner, C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeoseqRestrictSTBOX wraps MEOS C function tgeoseq_restrict_stbox. -func TgeoseqRestrictSTBOX(seq *TSequence, box *STBox, border_inc bool, atfunc bool) *Temporal { +func TgeoseqRestrictSTBOX(seq *TSequence, box *STBox, border_inc bool, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeoseq_restrict_stbox(seq._inner, box._inner, C.bool(border_inc), C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeoseqsetRestrictGeom wraps MEOS C function tgeoseqset_restrict_geom. -func TgeoseqsetRestrictGeom(ss *TSequenceSet, gs *Geom, atfunc bool) *TSequenceSet { +func TgeoseqsetRestrictGeom(ss *TSequenceSet, gs *Geom, atfunc bool) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tgeoseqset_restrict_geom(ss._inner, gs._inner, C.bool(atfunc)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TgeoseqsetRestrictSTBOX wraps MEOS C function tgeoseqset_restrict_stbox. -func TgeoseqsetRestrictSTBOX(ss *TSequenceSet, box *STBox, border_inc bool, atfunc bool) *TSequenceSet { +func TgeoseqsetRestrictSTBOX(ss *TSequenceSet, box *STBox, border_inc bool, atfunc bool) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tgeoseqset_restrict_stbox(ss._inner, box._inner, C.bool(border_inc), C.bool(atfunc)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // GeoClipCtxMake wraps MEOS C function geo_clip_ctx_make. -func GeoClipCtxMake(gs *Geom) unsafe.Pointer { +func GeoClipCtxMake(gs *Geom) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.geo_clip_ctx_make(gs._inner) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // GeoClipCtxFree wraps MEOS C function geo_clip_ctx_free. -func GeoClipCtxFree(ctx unsafe.Pointer) { +func GeoClipCtxFree(ctx unsafe.Pointer) (_err error) { + C.meos_errno_reset() C.geo_clip_ctx_free(unsafe.Pointer(ctx)) + if _err = meosError(); _err != nil { + return + } + return nil } // GeoIntersects2d wraps MEOS C function geo_intersects2d. -func GeoIntersects2d(gs1 *Geom, gs2 *Geom) bool { +func GeoIntersects2d(gs1 *Geom, gs2 *Geom) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.geo_intersects2d(gs1._inner, gs2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // GeoIntersects2dCtx wraps MEOS C function geo_intersects2d_ctx. -func GeoIntersects2dCtx(gs *Geom, ctx unsafe.Pointer) bool { +func GeoIntersects2dCtx(gs *Geom, ctx unsafe.Pointer) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.geo_intersects2d_ctx(gs._inner, unsafe.Pointer(ctx)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // GeoCovers2d wraps MEOS C function geo_covers2d. -func GeoCovers2d(gs1 *Geom, gs2 *Geom) bool { +func GeoCovers2d(gs1 *Geom, gs2 *Geom) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.geo_covers2d(gs1._inner, gs2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TpointLinearInterGeom wraps MEOS C function tpoint_linear_inter_geom. -func TpointLinearInterGeom(temp *Temporal, gs *Geom, clip bool) *Temporal { +func TpointLinearInterGeom(temp *Temporal, gs *Geom, clip bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpoint_linear_inter_geom(temp._inner, gs._inner, C.bool(clip)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpointLinearInterGeomCtx wraps MEOS C function tpoint_linear_inter_geom_ctx. -func TpointLinearInterGeomCtx(temp *Temporal, ctx unsafe.Pointer, clip bool) *Temporal { +func TpointLinearInterGeomCtx(temp *Temporal, ctx unsafe.Pointer, clip bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpoint_linear_inter_geom_ctx(temp._inner, unsafe.Pointer(ctx), C.bool(clip)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpointLinearDwithinGeom wraps MEOS C function tpoint_linear_dwithin_geom. -func TpointLinearDwithinGeom(temp *Temporal, gs *Geom, dist float64) *Temporal { +func TpointLinearDwithinGeom(temp *Temporal, gs *Geom, dist float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpoint_linear_dwithin_geom(temp._inner, gs._inner, C.double(dist)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpointLinearDwithinGeomCtx wraps MEOS C function tpoint_linear_dwithin_geom_ctx. -func TpointLinearDwithinGeomCtx(temp *Temporal, ctx unsafe.Pointer, dist float64) *Temporal { +func TpointLinearDwithinGeomCtx(temp *Temporal, ctx unsafe.Pointer, dist float64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpoint_linear_dwithin_geom_ctx(temp._inner, unsafe.Pointer(ctx), C.double(dist)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpointLinearDistanceGeom wraps MEOS C function tpoint_linear_distance_geom. -func TpointLinearDistanceGeom(temp *Temporal, gs *Geom) *Temporal { +func TpointLinearDistanceGeom(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpoint_linear_distance_geom(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpointLinearRestrictGeom wraps MEOS C function tpoint_linear_restrict_geom. -func TpointLinearRestrictGeom(temp *Temporal, gs *Geom, atfunc bool) *Temporal { +func TpointLinearRestrictGeom(temp *Temporal, gs *Geom, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpoint_linear_restrict_geom(temp._inner, gs._inner, C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // GeomClipSupported wraps MEOS C function geom_clip_supported. -func GeomClipSupported(geom unsafe.Pointer) bool { +func GeomClipSupported(geom unsafe.Pointer) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.geom_clip_supported((*C.LWGEOM)(unsafe.Pointer(geom))) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TspatialinstSRID wraps MEOS C function tspatialinst_srid. -func TspatialinstSRID(inst *TInstant) int { +func TspatialinstSRID(inst *TInstant) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.tspatialinst_srid(inst._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TpointseqAzimuth wraps MEOS C function tpointseq_azimuth. -func TpointseqAzimuth(seq *TSequence) *TSequenceSet { +func TpointseqAzimuth(seq *TSequence) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tpointseq_azimuth(seq._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TpointseqCumulativeLength wraps MEOS C function tpointseq_cumulative_length. -func TpointseqCumulativeLength(seq *TSequence, prevlength float64) *TSequence { +func TpointseqCumulativeLength(seq *TSequence, prevlength float64) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tpointseq_cumulative_length(seq._inner, C.double(prevlength)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TpointseqIsSimple wraps MEOS C function tpointseq_is_simple. -func TpointseqIsSimple(seq *TSequence) bool { +func TpointseqIsSimple(seq *TSequence) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tpointseq_is_simple(seq._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TpointseqLength wraps MEOS C function tpointseq_length. -func TpointseqLength(seq *TSequence) float64 { +func TpointseqLength(seq *TSequence) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.tpointseq_length(seq._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TpointseqLinearTrajectory wraps MEOS C function tpointseq_linear_trajectory. -func TpointseqLinearTrajectory(seq *TSequence, unary_union bool) *Geom { +func TpointseqLinearTrajectory(seq *TSequence, unary_union bool) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.tpointseq_linear_trajectory(seq._inner, C.bool(unary_union)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // TgeoseqStboxes wraps MEOS C function tgeoseq_stboxes. -func TgeoseqStboxes(seq *TSequence, count unsafe.Pointer) *STBox { +func TgeoseqStboxes(seq *TSequence, count unsafe.Pointer) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.tgeoseq_stboxes(seq._inner, (*C.int)(unsafe.Pointer(count))) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // TgeoseqSplitNStboxes wraps MEOS C function tgeoseq_split_n_stboxes. -func TgeoseqSplitNStboxes(seq *TSequence, max_count int, count unsafe.Pointer) *STBox { +func TgeoseqSplitNStboxes(seq *TSequence, max_count int, count unsafe.Pointer) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.tgeoseq_split_n_stboxes(seq._inner, C.int(max_count), (*C.int)(unsafe.Pointer(count))) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // TpointseqsetAzimuth wraps MEOS C function tpointseqset_azimuth. -func TpointseqsetAzimuth(ss *TSequenceSet) *TSequenceSet { +func TpointseqsetAzimuth(ss *TSequenceSet) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tpointseqset_azimuth(ss._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TpointseqsetCumulativeLength wraps MEOS C function tpointseqset_cumulative_length. -func TpointseqsetCumulativeLength(ss *TSequenceSet) *TSequenceSet { +func TpointseqsetCumulativeLength(ss *TSequenceSet) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tpointseqset_cumulative_length(ss._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TpointseqsetIsSimple wraps MEOS C function tpointseqset_is_simple. -func TpointseqsetIsSimple(ss *TSequenceSet) bool { +func TpointseqsetIsSimple(ss *TSequenceSet) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tpointseqset_is_simple(ss._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TpointseqsetLength wraps MEOS C function tpointseqset_length. -func TpointseqsetLength(ss *TSequenceSet) float64 { +func TpointseqsetLength(ss *TSequenceSet) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.tpointseqset_length(ss._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TgeoseqsetStboxes wraps MEOS C function tgeoseqset_stboxes. -func TgeoseqsetStboxes(ss *TSequenceSet, count unsafe.Pointer) *STBox { +func TgeoseqsetStboxes(ss *TSequenceSet, count unsafe.Pointer) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.tgeoseqset_stboxes(ss._inner, (*C.int)(unsafe.Pointer(count))) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // TgeoseqsetSplitNStboxes wraps MEOS C function tgeoseqset_split_n_stboxes. -func TgeoseqsetSplitNStboxes(ss *TSequenceSet, max_count int, count unsafe.Pointer) *STBox { +func TgeoseqsetSplitNStboxes(ss *TSequenceSet, max_count int, count unsafe.Pointer) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.tgeoseqset_split_n_stboxes(ss._inner, C.int(max_count), (*C.int)(unsafe.Pointer(count))) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // TgeominstTgeoginst wraps MEOS C function tgeominst_tgeoginst. -func TgeominstTgeoginst(inst *TInstant, oper bool) *TInstant { +func TgeominstTgeoginst(inst *TInstant, oper bool) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tgeominst_tgeoginst(inst._inner, C.bool(oper)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TgeomseqTgeogseq wraps MEOS C function tgeomseq_tgeogseq. -func TgeomseqTgeogseq(seq *TSequence, oper bool) *TSequence { +func TgeomseqTgeogseq(seq *TSequence, oper bool) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tgeomseq_tgeogseq(seq._inner, C.bool(oper)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TgeomseqsetTgeogseqset wraps MEOS C function tgeomseqset_tgeogseqset. -func TgeomseqsetTgeogseqset(ss *TSequenceSet, oper bool) *TSequenceSet { +func TgeomseqsetTgeogseqset(ss *TSequenceSet, oper bool) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tgeomseqset_tgeogseqset(ss._inner, C.bool(oper)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TgeomTgeog wraps MEOS C function tgeom_tgeog. -func TgeomTgeog(temp *Temporal, oper bool) *Temporal { +func TgeomTgeog(temp *Temporal, oper bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeom_tgeog(temp._inner, C.bool(oper)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TgeoTpoint wraps MEOS C function tgeo_tpoint. -func TgeoTpoint(temp *Temporal, oper bool) *Temporal { +func TgeoTpoint(temp *Temporal, oper bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeo_tpoint(temp._inner, C.bool(oper)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TspatialinstSetSRID wraps MEOS C function tspatialinst_set_srid. -func TspatialinstSetSRID(inst *TInstant, srid int32) { +func TspatialinstSetSRID(inst *TInstant, srid int32) (_err error) { + C.meos_errno_reset() C.tspatialinst_set_srid(inst._inner, C.int32_t(srid)) + if _err = meosError(); _err != nil { + return + } + return nil } // TpointseqMakeSimple wraps MEOS C function tpointseq_make_simple. -func TpointseqMakeSimple(seq *TSequence, count unsafe.Pointer) unsafe.Pointer { +func TpointseqMakeSimple(seq *TSequence, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tpointseq_make_simple(seq._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TspatialseqSetSRID wraps MEOS C function tspatialseq_set_srid. -func TspatialseqSetSRID(seq *TSequence, srid int32) { +func TspatialseqSetSRID(seq *TSequence, srid int32) (_err error) { + C.meos_errno_reset() C.tspatialseq_set_srid(seq._inner, C.int32_t(srid)) + if _err = meosError(); _err != nil { + return + } + return nil } // TpointseqsetMakeSimple wraps MEOS C function tpointseqset_make_simple. -func TpointseqsetMakeSimple(ss *TSequenceSet, count unsafe.Pointer) unsafe.Pointer { +func TpointseqsetMakeSimple(ss *TSequenceSet, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tpointseqset_make_simple(ss._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TspatialseqsetSetSRID wraps MEOS C function tspatialseqset_set_srid. -func TspatialseqsetSetSRID(ss *TSequenceSet, srid int32) { +func TspatialseqsetSetSRID(ss *TSequenceSet, srid int32) (_err error) { + C.meos_errno_reset() C.tspatialseqset_set_srid(ss._inner, C.int32_t(srid)) + if _err = meosError(); _err != nil { + return + } + return nil } // TpointseqTwcentroid wraps MEOS C function tpointseq_twcentroid. -func TpointseqTwcentroid(seq *TSequence) *Geom { +func TpointseqTwcentroid(seq *TSequence) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.tpointseq_twcentroid(seq._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // TpointseqsetTwcentroid wraps MEOS C function tpointseqset_twcentroid. -func TpointseqsetTwcentroid(ss *TSequenceSet) *Geom { +func TpointseqsetTwcentroid(ss *TSequenceSet) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.tpointseqset_twcentroid(ss._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } diff --git a/functions/meos_meos_json.go b/functions/meos_meos_json.go index 16250d5..c783e54 100644 --- a/functions/meos_meos_json.go +++ b/functions/meos_meos_json.go @@ -86,94 +86,142 @@ import ( var _ = unsafe.Pointer(nil) // JSONIn wraps MEOS C function json_in. -func JSONIn(str string) string { +func JSONIn(str string) (_r0 string, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.json_in(_c_str) - return C.GoString(C.text_to_cstring(_cret)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(C.text_to_cstring(_cret)), nil } // JSONOut wraps MEOS C function json_out. -func JSONOut(js string) string { +func JSONOut(js string) (_r0 string, _err error) { _c_js := C.cstring_to_text(C.CString(js)) defer C.free(unsafe.Pointer(_c_js)) + C.meos_errno_reset() _cret := C.json_out(_c_js) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // JsonbFromText wraps MEOS C function jsonb_from_text. -func JsonbFromText(txt string, unique_keys bool) *Jsonb { +func JsonbFromText(txt string, unique_keys bool) (_r0 *Jsonb, _err error) { _c_txt := C.cstring_to_text(C.CString(txt)) defer C.free(unsafe.Pointer(_c_txt)) + C.meos_errno_reset() _cret := C.jsonb_from_text(_c_txt, C.bool(unique_keys)) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // JsonbIn wraps MEOS C function jsonb_in. -func JsonbIn(str string) *Jsonb { +func JsonbIn(str string) (_r0 *Jsonb, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.jsonb_in(_c_str) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // JsonbOut wraps MEOS C function jsonb_out. -func JsonbOut(jb *Jsonb) string { +func JsonbOut(jb *Jsonb) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.jsonb_out(jb._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // JSONMake wraps MEOS C function json_make. -func JSONMake(keys_vals unsafe.Pointer, count int) string { +func JSONMake(keys_vals unsafe.Pointer, count int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.json_make((**C.text)(unsafe.Pointer(keys_vals)), C.int(count)) - return C.GoString(C.text_to_cstring(_cret)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(C.text_to_cstring(_cret)), nil } // JSONMakeTwoArg wraps MEOS C function json_make_two_arg. -func JSONMakeTwoArg(keys unsafe.Pointer, values unsafe.Pointer, count int) string { +func JSONMakeTwoArg(keys unsafe.Pointer, values unsafe.Pointer, count int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.json_make_two_arg((**C.text)(unsafe.Pointer(keys)), (**C.text)(unsafe.Pointer(values)), C.int(count)) - return C.GoString(C.text_to_cstring(_cret)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(C.text_to_cstring(_cret)), nil } // JsonbCopy wraps MEOS C function jsonb_copy. -func JsonbCopy(jb *Jsonb) *Jsonb { +func JsonbCopy(jb *Jsonb) (_r0 *Jsonb, _err error) { + C.meos_errno_reset() _cret := C.jsonb_copy(jb._inner) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // JsonbMake wraps MEOS C function jsonb_make. -func JsonbMake(keys_vals unsafe.Pointer, count int) *Jsonb { +func JsonbMake(keys_vals unsafe.Pointer, count int) (_r0 *Jsonb, _err error) { + C.meos_errno_reset() _cret := C.jsonb_make((**C.text)(unsafe.Pointer(keys_vals)), C.int(count)) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // JsonbMakeTwoArg wraps MEOS C function jsonb_make_two_arg. -func JsonbMakeTwoArg(keys unsafe.Pointer, values unsafe.Pointer, count int) *Jsonb { +func JsonbMakeTwoArg(keys unsafe.Pointer, values unsafe.Pointer, count int) (_r0 *Jsonb, _err error) { + C.meos_errno_reset() _cret := C.jsonb_make_two_arg((**C.text)(unsafe.Pointer(keys)), (**C.text)(unsafe.Pointer(values)), C.int(count)) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // JsonbToBool wraps MEOS C function jsonb_to_bool. -func JsonbToBool(jb *Jsonb) bool { +func JsonbToBool(jb *Jsonb) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.jsonb_to_bool(jb._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // JsonbToCstring wraps MEOS C function jsonb_to_cstring. -func JsonbToCstring(jb *Jsonb) string { +func JsonbToCstring(jb *Jsonb) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.jsonb_to_cstring(jb._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } @@ -186,23 +234,35 @@ func JsonbToCstring(jb *Jsonb) string { // JsonbToInt16 wraps MEOS C function jsonb_to_int16. -func JsonbToInt16(jb *Jsonb) int16 { +func JsonbToInt16(jb *Jsonb) (_r0 int16, _err error) { + C.meos_errno_reset() _cret := C.jsonb_to_int16(jb._inner) - return int16(_cret) + if _err = meosError(); _err != nil { + return + } + return int16(_cret), nil } // JsonbToInt32 wraps MEOS C function jsonb_to_int32. -func JsonbToInt32(jb *Jsonb) int32 { +func JsonbToInt32(jb *Jsonb) (_r0 int32, _err error) { + C.meos_errno_reset() _cret := C.jsonb_to_int32(jb._inner) - return int32(_cret) + if _err = meosError(); _err != nil { + return + } + return int32(_cret), nil } // JsonbToInt64 wraps MEOS C function jsonb_to_int64. -func JsonbToInt64(jb *Jsonb) int64 { +func JsonbToInt64(jb *Jsonb) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.jsonb_to_int64(jb._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } @@ -211,1281 +271,1957 @@ func JsonbToInt64(jb *Jsonb) int64 { // JsonbToText wraps MEOS C function jsonb_to_text. -func JsonbToText(jb *Jsonb) string { +func JsonbToText(jb *Jsonb) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.jsonb_to_text(jb._inner) - return C.GoString(C.text_to_cstring(_cret)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(C.text_to_cstring(_cret)), nil } // JSONArrayElement wraps MEOS C function json_array_element. -func JSONArrayElement(js string, element int) string { +func JSONArrayElement(js string, element int) (_r0 string, _err error) { _c_js := C.cstring_to_text(C.CString(js)) defer C.free(unsafe.Pointer(_c_js)) + C.meos_errno_reset() _cret := C.json_array_element(_c_js, C.int(element)) - return C.GoString(C.text_to_cstring(_cret)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(C.text_to_cstring(_cret)), nil } // JSONArrayElementText wraps MEOS C function json_array_element_text. -func JSONArrayElementText(js string, element int) string { +func JSONArrayElementText(js string, element int) (_r0 string, _err error) { _c_js := C.cstring_to_text(C.CString(js)) defer C.free(unsafe.Pointer(_c_js)) + C.meos_errno_reset() _cret := C.json_array_element_text(_c_js, C.int(element)) - return C.GoString(C.text_to_cstring(_cret)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(C.text_to_cstring(_cret)), nil } // JSONArrayElements wraps MEOS C function json_array_elements. -func JSONArrayElements(js string, count unsafe.Pointer) unsafe.Pointer { +func JSONArrayElements(js string, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { _c_js := C.cstring_to_text(C.CString(js)) defer C.free(unsafe.Pointer(_c_js)) + C.meos_errno_reset() _cret := C.json_array_elements(_c_js, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // JSONArrayElementsText wraps MEOS C function json_array_elements_text. -func JSONArrayElementsText(js string, count unsafe.Pointer) unsafe.Pointer { +func JSONArrayElementsText(js string, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { _c_js := C.cstring_to_text(C.CString(js)) defer C.free(unsafe.Pointer(_c_js)) + C.meos_errno_reset() _cret := C.json_array_elements_text(_c_js, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // JSONArrayLength wraps MEOS C function json_array_length. -func JSONArrayLength(js string) int { +func JSONArrayLength(js string) (_r0 int, _err error) { _c_js := C.cstring_to_text(C.CString(js)) defer C.free(unsafe.Pointer(_c_js)) + C.meos_errno_reset() _cret := C.json_array_length(_c_js) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // JSONEach wraps MEOS C function json_each. -func JSONEach(js string, values unsafe.Pointer, count unsafe.Pointer) unsafe.Pointer { +func JSONEach(js string, values unsafe.Pointer, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { _c_js := C.cstring_to_text(C.CString(js)) defer C.free(unsafe.Pointer(_c_js)) + C.meos_errno_reset() _cret := C.json_each(_c_js, (**C.text)(unsafe.Pointer(values)), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // JSONEachText wraps MEOS C function json_each_text. -func JSONEachText(js string, values unsafe.Pointer, count unsafe.Pointer) unsafe.Pointer { +func JSONEachText(js string, values unsafe.Pointer, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { _c_js := C.cstring_to_text(C.CString(js)) defer C.free(unsafe.Pointer(_c_js)) + C.meos_errno_reset() _cret := C.json_each_text(_c_js, (**C.text)(unsafe.Pointer(values)), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // JSONExtractPath wraps MEOS C function json_extract_path. -func JSONExtractPath(js string, path_elems unsafe.Pointer, path_len int) string { +func JSONExtractPath(js string, path_elems unsafe.Pointer, path_len int) (_r0 string, _err error) { _c_js := C.cstring_to_text(C.CString(js)) defer C.free(unsafe.Pointer(_c_js)) + C.meos_errno_reset() _cret := C.json_extract_path(_c_js, (**C.text)(unsafe.Pointer(path_elems)), C.int(path_len)) - return C.GoString(C.text_to_cstring(_cret)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(C.text_to_cstring(_cret)), nil } // JSONExtractPathText wraps MEOS C function json_extract_path_text. -func JSONExtractPathText(js string, path_elems unsafe.Pointer, path_len int) string { +func JSONExtractPathText(js string, path_elems unsafe.Pointer, path_len int) (_r0 string, _err error) { _c_js := C.cstring_to_text(C.CString(js)) defer C.free(unsafe.Pointer(_c_js)) + C.meos_errno_reset() _cret := C.json_extract_path_text(_c_js, (**C.text)(unsafe.Pointer(path_elems)), C.int(path_len)) - return C.GoString(C.text_to_cstring(_cret)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(C.text_to_cstring(_cret)), nil } // JSONObjectField wraps MEOS C function json_object_field. -func JSONObjectField(js string, key string) string { +func JSONObjectField(js string, key string) (_r0 string, _err error) { _c_js := C.cstring_to_text(C.CString(js)) defer C.free(unsafe.Pointer(_c_js)) _c_key := C.cstring_to_text(C.CString(key)) defer C.free(unsafe.Pointer(_c_key)) + C.meos_errno_reset() _cret := C.json_object_field(_c_js, _c_key) - return C.GoString(C.text_to_cstring(_cret)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(C.text_to_cstring(_cret)), nil } // JSONObjectFieldText wraps MEOS C function json_object_field_text. -func JSONObjectFieldText(js string, key string) string { +func JSONObjectFieldText(js string, key string) (_r0 string, _err error) { _c_js := C.cstring_to_text(C.CString(js)) defer C.free(unsafe.Pointer(_c_js)) _c_key := C.cstring_to_text(C.CString(key)) defer C.free(unsafe.Pointer(_c_key)) + C.meos_errno_reset() _cret := C.json_object_field_text(_c_js, _c_key) - return C.GoString(C.text_to_cstring(_cret)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(C.text_to_cstring(_cret)), nil } // JSONObjectKeys wraps MEOS C function json_object_keys. -func JSONObjectKeys(js string, count unsafe.Pointer) unsafe.Pointer { +func JSONObjectKeys(js string, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { _c_js := C.cstring_to_text(C.CString(js)) defer C.free(unsafe.Pointer(_c_js)) + C.meos_errno_reset() _cret := C.json_object_keys(_c_js, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // JSONTypeof wraps MEOS C function json_typeof. -func JSONTypeof(js string) string { +func JSONTypeof(js string) (_r0 string, _err error) { _c_js := C.cstring_to_text(C.CString(js)) defer C.free(unsafe.Pointer(_c_js)) + C.meos_errno_reset() _cret := C.json_typeof(_c_js) - return C.GoString(C.text_to_cstring(_cret)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(C.text_to_cstring(_cret)), nil } // JsonbArrayElement wraps MEOS C function jsonb_array_element. -func JsonbArrayElement(jb *Jsonb, element int) *Jsonb { +func JsonbArrayElement(jb *Jsonb, element int) (_r0 *Jsonb, _err error) { + C.meos_errno_reset() _cret := C.jsonb_array_element(jb._inner, C.int(element)) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // JsonbArrayElementText wraps MEOS C function jsonb_array_element_text. -func JsonbArrayElementText(jb *Jsonb, element int) string { +func JsonbArrayElementText(jb *Jsonb, element int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.jsonb_array_element_text(jb._inner, C.int(element)) - return C.GoString(C.text_to_cstring(_cret)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(C.text_to_cstring(_cret)), nil } // JsonbArrayElements wraps MEOS C function jsonb_array_elements. -func JsonbArrayElements(jb *Jsonb, count unsafe.Pointer) unsafe.Pointer { +func JsonbArrayElements(jb *Jsonb, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.jsonb_array_elements(jb._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // JsonbArrayElementsText wraps MEOS C function jsonb_array_elements_text. -func JsonbArrayElementsText(jb *Jsonb, count unsafe.Pointer) unsafe.Pointer { +func JsonbArrayElementsText(jb *Jsonb, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.jsonb_array_elements_text(jb._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // JsonbArrayLength wraps MEOS C function jsonb_array_length. -func JsonbArrayLength(jb *Jsonb) int { +func JsonbArrayLength(jb *Jsonb) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.jsonb_array_length(jb._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // JsonbContained wraps MEOS C function jsonb_contained. -func JsonbContained(jb1 *Jsonb, jb2 *Jsonb) bool { +func JsonbContained(jb1 *Jsonb, jb2 *Jsonb) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.jsonb_contained(jb1._inner, jb2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // JsonbContains wraps MEOS C function jsonb_contains. -func JsonbContains(jb1 *Jsonb, jb2 *Jsonb) bool { +func JsonbContains(jb1 *Jsonb, jb2 *Jsonb) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.jsonb_contains(jb1._inner, jb2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // JsonbEach wraps MEOS C function jsonb_each. -func JsonbEach(jb *Jsonb, values unsafe.Pointer, count unsafe.Pointer) unsafe.Pointer { +func JsonbEach(jb *Jsonb, values unsafe.Pointer, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.jsonb_each(jb._inner, (**C.Jsonb)(unsafe.Pointer(values)), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // JsonbEachText wraps MEOS C function jsonb_each_text. -func JsonbEachText(jb *Jsonb, values unsafe.Pointer, count unsafe.Pointer) unsafe.Pointer { +func JsonbEachText(jb *Jsonb, values unsafe.Pointer, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.jsonb_each_text(jb._inner, (**C.text)(unsafe.Pointer(values)), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // JsonbExists wraps MEOS C function jsonb_exists. -func JsonbExists(jb *Jsonb, key string) bool { +func JsonbExists(jb *Jsonb, key string) (_r0 bool, _err error) { _c_key := C.cstring_to_text(C.CString(key)) defer C.free(unsafe.Pointer(_c_key)) + C.meos_errno_reset() _cret := C.jsonb_exists(jb._inner, _c_key) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // JsonbExistsArray wraps MEOS C function jsonb_exists_array. -func JsonbExistsArray(jb *Jsonb, keys_elems unsafe.Pointer, keys_len int, any bool) bool { +func JsonbExistsArray(jb *Jsonb, keys_elems unsafe.Pointer, keys_len int, any bool) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.jsonb_exists_array(jb._inner, (**C.text)(unsafe.Pointer(keys_elems)), C.int(keys_len), C.bool(any)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // JsonbExtractPath wraps MEOS C function jsonb_extract_path. -func JsonbExtractPath(jb *Jsonb, path_elems unsafe.Pointer, path_len int) *Jsonb { +func JsonbExtractPath(jb *Jsonb, path_elems unsafe.Pointer, path_len int) (_r0 *Jsonb, _err error) { + C.meos_errno_reset() _cret := C.jsonb_extract_path(jb._inner, (**C.text)(unsafe.Pointer(path_elems)), C.int(path_len)) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // JsonbExtractPathText wraps MEOS C function jsonb_extract_path_text. -func JsonbExtractPathText(jb *Jsonb, path_elems unsafe.Pointer, path_len int) string { +func JsonbExtractPathText(jb *Jsonb, path_elems unsafe.Pointer, path_len int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.jsonb_extract_path_text(jb._inner, (**C.text)(unsafe.Pointer(path_elems)), C.int(path_len)) - return C.GoString(C.text_to_cstring(_cret)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(C.text_to_cstring(_cret)), nil } // JsonbHash wraps MEOS C function jsonb_hash. -func JsonbHash(jb *Jsonb) uint32 { +func JsonbHash(jb *Jsonb) (_r0 uint32, _err error) { + C.meos_errno_reset() _cret := C.jsonb_hash(jb._inner) - return uint32(_cret) + if _err = meosError(); _err != nil { + return + } + return uint32(_cret), nil } // JsonbHashExtended wraps MEOS C function jsonb_hash_extended. -func JsonbHashExtended(jb *Jsonb, seed uint64) uint64 { +func JsonbHashExtended(jb *Jsonb, seed uint64) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.jsonb_hash_extended(jb._inner, C.uint64_t(seed)) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // JsonbObjectField wraps MEOS C function jsonb_object_field. -func JsonbObjectField(jb *Jsonb, key string) *Jsonb { +func JsonbObjectField(jb *Jsonb, key string) (_r0 *Jsonb, _err error) { _c_key := C.cstring_to_text(C.CString(key)) defer C.free(unsafe.Pointer(_c_key)) + C.meos_errno_reset() _cret := C.jsonb_object_field(jb._inner, _c_key) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // JsonbObjectFieldText wraps MEOS C function jsonb_object_field_text. -func JsonbObjectFieldText(jb *Jsonb, key string) string { +func JsonbObjectFieldText(jb *Jsonb, key string) (_r0 string, _err error) { _c_key := C.cstring_to_text(C.CString(key)) defer C.free(unsafe.Pointer(_c_key)) + C.meos_errno_reset() _cret := C.jsonb_object_field_text(jb._inner, _c_key) - return C.GoString(C.text_to_cstring(_cret)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(C.text_to_cstring(_cret)), nil } // JsonbObjectKeys wraps MEOS C function jsonb_object_keys. -func JsonbObjectKeys(jb *Jsonb, count unsafe.Pointer) unsafe.Pointer { +func JsonbObjectKeys(jb *Jsonb, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.jsonb_object_keys(jb._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // JSONStripNulls wraps MEOS C function json_strip_nulls. -func JSONStripNulls(js string, strip_in_arrays bool) string { +func JSONStripNulls(js string, strip_in_arrays bool) (_r0 string, _err error) { _c_js := C.cstring_to_text(C.CString(js)) defer C.free(unsafe.Pointer(_c_js)) + C.meos_errno_reset() _cret := C.json_strip_nulls(_c_js, C.bool(strip_in_arrays)) - return C.GoString(C.text_to_cstring(_cret)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(C.text_to_cstring(_cret)), nil } // JsonbConcat wraps MEOS C function jsonb_concat. -func JsonbConcat(jb1 *Jsonb, jb2 *Jsonb) *Jsonb { +func JsonbConcat(jb1 *Jsonb, jb2 *Jsonb) (_r0 *Jsonb, _err error) { + C.meos_errno_reset() _cret := C.jsonb_concat(jb1._inner, jb2._inner) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // JsonbDelete wraps MEOS C function jsonb_delete. -func JsonbDelete(jb *Jsonb, key string) *Jsonb { +func JsonbDelete(jb *Jsonb, key string) (_r0 *Jsonb, _err error) { _c_key := C.cstring_to_text(C.CString(key)) defer C.free(unsafe.Pointer(_c_key)) + C.meos_errno_reset() _cret := C.jsonb_delete(jb._inner, _c_key) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // JsonbDeleteArray wraps MEOS C function jsonb_delete_array. -func JsonbDeleteArray(jb *Jsonb, keys_elems unsafe.Pointer, keys_len int) *Jsonb { +func JsonbDeleteArray(jb *Jsonb, keys_elems unsafe.Pointer, keys_len int) (_r0 *Jsonb, _err error) { + C.meos_errno_reset() _cret := C.jsonb_delete_array(jb._inner, (**C.text)(unsafe.Pointer(keys_elems)), C.int(keys_len)) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // JsonbDeleteIndex wraps MEOS C function jsonb_delete_index. -func JsonbDeleteIndex(jb *Jsonb, idx int) *Jsonb { +func JsonbDeleteIndex(jb *Jsonb, idx int) (_r0 *Jsonb, _err error) { + C.meos_errno_reset() _cret := C.jsonb_delete_index(jb._inner, C.int(idx)) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // JsonbDeletePath wraps MEOS C function jsonb_delete_path. -func JsonbDeletePath(jb *Jsonb, path_elems unsafe.Pointer, path_len int) *Jsonb { +func JsonbDeletePath(jb *Jsonb, path_elems unsafe.Pointer, path_len int) (_r0 *Jsonb, _err error) { + C.meos_errno_reset() _cret := C.jsonb_delete_path(jb._inner, (**C.text)(unsafe.Pointer(path_elems)), C.int(path_len)) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // JsonbInsert wraps MEOS C function jsonb_insert. -func JsonbInsert(jb *Jsonb, path_elems unsafe.Pointer, path_len int, newjb *Jsonb, after bool) *Jsonb { +func JsonbInsert(jb *Jsonb, path_elems unsafe.Pointer, path_len int, newjb *Jsonb, after bool) (_r0 *Jsonb, _err error) { + C.meos_errno_reset() _cret := C.jsonb_insert(jb._inner, (**C.text)(unsafe.Pointer(path_elems)), C.int(path_len), newjb._inner, C.bool(after)) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // JsonbPretty wraps MEOS C function jsonb_pretty. -func JsonbPretty(jb *Jsonb) string { +func JsonbPretty(jb *Jsonb) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.jsonb_pretty(jb._inner) - return C.GoString(C.text_to_cstring(_cret)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(C.text_to_cstring(_cret)), nil } // JsonbSet wraps MEOS C function jsonb_set. -func JsonbSet(jb *Jsonb, path_elems unsafe.Pointer, path_len int, newjb *Jsonb, create bool) *Jsonb { +func JsonbSet(jb *Jsonb, path_elems unsafe.Pointer, path_len int, newjb *Jsonb, create bool) (_r0 *Jsonb, _err error) { + C.meos_errno_reset() _cret := C.jsonb_set(jb._inner, (**C.text)(unsafe.Pointer(path_elems)), C.int(path_len), newjb._inner, C.bool(create)) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // JsonbSetLax wraps MEOS C function jsonb_set_lax. -func JsonbSetLax(jb *Jsonb, path_elems unsafe.Pointer, path_len int, newjb *Jsonb, create bool, handle_null string) *Jsonb { +func JsonbSetLax(jb *Jsonb, path_elems unsafe.Pointer, path_len int, newjb *Jsonb, create bool, handle_null string) (_r0 *Jsonb, _err error) { _c_handle_null := C.cstring_to_text(C.CString(handle_null)) defer C.free(unsafe.Pointer(_c_handle_null)) + C.meos_errno_reset() _cret := C.jsonb_set_lax(jb._inner, (**C.text)(unsafe.Pointer(path_elems)), C.int(path_len), newjb._inner, C.bool(create), _c_handle_null) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // JsonbStripNulls wraps MEOS C function jsonb_strip_nulls. -func JsonbStripNulls(jb *Jsonb, strip_in_arrays bool) *Jsonb { +func JsonbStripNulls(jb *Jsonb, strip_in_arrays bool) (_r0 *Jsonb, _err error) { + C.meos_errno_reset() _cret := C.jsonb_strip_nulls(jb._inner, C.bool(strip_in_arrays)) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // JsonbCmp wraps MEOS C function jsonb_cmp. -func JsonbCmp(jb1 *Jsonb, jb2 *Jsonb) int { +func JsonbCmp(jb1 *Jsonb, jb2 *Jsonb) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.jsonb_cmp(jb1._inner, jb2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // JsonbEq wraps MEOS C function jsonb_eq. -func JsonbEq(jb1 *Jsonb, jb2 *Jsonb) bool { +func JsonbEq(jb1 *Jsonb, jb2 *Jsonb) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.jsonb_eq(jb1._inner, jb2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // JsonbGe wraps MEOS C function jsonb_ge. -func JsonbGe(jb1 *Jsonb, jb2 *Jsonb) bool { +func JsonbGe(jb1 *Jsonb, jb2 *Jsonb) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.jsonb_ge(jb1._inner, jb2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // JsonbGt wraps MEOS C function jsonb_gt. -func JsonbGt(jb1 *Jsonb, jb2 *Jsonb) bool { +func JsonbGt(jb1 *Jsonb, jb2 *Jsonb) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.jsonb_gt(jb1._inner, jb2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // JsonbLe wraps MEOS C function jsonb_le. -func JsonbLe(jb1 *Jsonb, jb2 *Jsonb) bool { +func JsonbLe(jb1 *Jsonb, jb2 *Jsonb) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.jsonb_le(jb1._inner, jb2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // JsonbLt wraps MEOS C function jsonb_lt. -func JsonbLt(jb1 *Jsonb, jb2 *Jsonb) bool { +func JsonbLt(jb1 *Jsonb, jb2 *Jsonb) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.jsonb_lt(jb1._inner, jb2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // JsonbNe wraps MEOS C function jsonb_ne. -func JsonbNe(jb1 *Jsonb, jb2 *Jsonb) bool { +func JsonbNe(jb1 *Jsonb, jb2 *Jsonb) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.jsonb_ne(jb1._inner, jb2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // JsonbPathExists wraps MEOS C function jsonb_path_exists. -func JsonbPathExists(jb *Jsonb, jp *JsonPath, vars *Jsonb, silent bool, tz bool) int { +func JsonbPathExists(jb *Jsonb, jp *JsonPath, vars *Jsonb, silent bool, tz bool) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.jsonb_path_exists(jb._inner, jp._inner, vars._inner, C.bool(silent), C.bool(tz)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // JsonbPathMatch wraps MEOS C function jsonb_path_match. -func JsonbPathMatch(jb *Jsonb, jp *JsonPath, vars *Jsonb, silent bool, tz bool) bool { +func JsonbPathMatch(jb *Jsonb, jp *JsonPath, vars *Jsonb, silent bool, tz bool) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.jsonb_path_match(jb._inner, jp._inner, vars._inner, C.bool(silent), C.bool(tz)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // JsonbPathQueryAll wraps MEOS C function jsonb_path_query_all. -func JsonbPathQueryAll(jb *Jsonb, jp *JsonPath, vars *Jsonb, silent bool, tz bool, count unsafe.Pointer) unsafe.Pointer { +func JsonbPathQueryAll(jb *Jsonb, jp *JsonPath, vars *Jsonb, silent bool, tz bool, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.jsonb_path_query_all(jb._inner, jp._inner, vars._inner, C.bool(silent), C.bool(tz), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // JsonbPathQueryArray wraps MEOS C function jsonb_path_query_array. -func JsonbPathQueryArray(jb *Jsonb, jp *JsonPath, vars *Jsonb, silent bool, tz bool) *Jsonb { +func JsonbPathQueryArray(jb *Jsonb, jp *JsonPath, vars *Jsonb, silent bool, tz bool) (_r0 *Jsonb, _err error) { + C.meos_errno_reset() _cret := C.jsonb_path_query_array(jb._inner, jp._inner, vars._inner, C.bool(silent), C.bool(tz)) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // JsonbPathQueryFirst wraps MEOS C function jsonb_path_query_first. -func JsonbPathQueryFirst(jb *Jsonb, jp *JsonPath, vars *Jsonb, silent bool, tz bool) *Jsonb { +func JsonbPathQueryFirst(jb *Jsonb, jp *JsonPath, vars *Jsonb, silent bool, tz bool) (_r0 *Jsonb, _err error) { + C.meos_errno_reset() _cret := C.jsonb_path_query_first(jb._inner, jp._inner, vars._inner, C.bool(silent), C.bool(tz)) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // JsonpathIn wraps MEOS C function jsonpath_in. -func JsonpathIn(str string) *JsonPath { +func JsonpathIn(str string) (_r0 *JsonPath, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.jsonpath_in(_c_str) - return &JsonPath{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &JsonPath{_inner: _cret}, nil } // JsonpathCopy wraps MEOS C function jsonpath_copy. -func JsonpathCopy(jp *JsonPath) *JsonPath { +func JsonpathCopy(jp *JsonPath) (_r0 *JsonPath, _err error) { + C.meos_errno_reset() _cret := C.jsonpath_copy(jp._inner) - return &JsonPath{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &JsonPath{_inner: _cret}, nil } // JsonpathOut wraps MEOS C function jsonpath_out. -func JsonpathOut(jp *JsonPath) string { +func JsonpathOut(jp *JsonPath) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.jsonpath_out(jp._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // JsonbsetIn wraps MEOS C function jsonbset_in. -func JsonbsetIn(str string) *Set { +func JsonbsetIn(str string) (_r0 *Set, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.jsonbset_in(_c_str) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbsetOut wraps MEOS C function jsonbset_out. -func JsonbsetOut(s *Set, maxdd int) string { +func JsonbsetOut(s *Set, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.jsonbset_out(s._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // JsonbsetMake wraps MEOS C function jsonbset_make. -func JsonbsetMake(values unsafe.Pointer, count int) *Set { +func JsonbsetMake(values unsafe.Pointer, count int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.jsonbset_make((**C.Jsonb)(unsafe.Pointer(values)), C.int(count)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbToSet wraps MEOS C function jsonb_to_set. -func JsonbToSet(jb *Jsonb) *Set { +func JsonbToSet(jb *Jsonb) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.jsonb_to_set(jb._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbsetEndValue wraps MEOS C function jsonbset_end_value. -func JsonbsetEndValue(s *Set) *Jsonb { +func JsonbsetEndValue(s *Set) (_r0 *Jsonb, _err error) { + C.meos_errno_reset() _cret := C.jsonbset_end_value(s._inner) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // JsonbsetStartValue wraps MEOS C function jsonbset_start_value. -func JsonbsetStartValue(s *Set) *Jsonb { +func JsonbsetStartValue(s *Set) (_r0 *Jsonb, _err error) { + C.meos_errno_reset() _cret := C.jsonbset_start_value(s._inner) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // JsonbsetValueN wraps MEOS C function jsonbset_value_n. -func JsonbsetValueN(s *Set, n int) (bool, *Jsonb) { +func JsonbsetValueN(s *Set, n int) (_r0 bool, _r1 *Jsonb, _err error) { var _out_result *C.Jsonb + C.meos_errno_reset() _cret := C.jsonbset_value_n(s._inner, C.int(n), &_out_result) - return bool(_cret), &Jsonb{_inner: _out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Jsonb{_inner: _out_result}, nil } // JsonbsetValues wraps MEOS C function jsonbset_values. -func JsonbsetValues(s *Set, count unsafe.Pointer) unsafe.Pointer { +func JsonbsetValues(s *Set, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.jsonbset_values(s._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // ConcatJsonbsetJsonb wraps MEOS C function concat_jsonbset_jsonb. -func ConcatJsonbsetJsonb(s *Set, jb *Jsonb, invert bool) *Set { +func ConcatJsonbsetJsonb(s *Set, jb *Jsonb, invert bool) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.concat_jsonbset_jsonb(s._inner, jb._inner, C.bool(invert)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbsetArrayLength wraps MEOS C function jsonbset_array_length. -func JsonbsetArrayLength(set *Set) *Set { +func JsonbsetArrayLength(set *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.jsonbset_array_length(set._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbsetObjectField wraps MEOS C function jsonbset_object_field. -func JsonbsetObjectField(set *Set, key string, astext bool, null_handle NullHandleType) *Set { +func JsonbsetObjectField(set *Set, key string, astext bool, null_handle NullHandleType) (_r0 *Set, _err error) { _c_key := C.cstring_to_text(C.CString(key)) defer C.free(unsafe.Pointer(_c_key)) + C.meos_errno_reset() _cret := C.jsonbset_object_field(set._inner, _c_key, C.bool(astext), C.nullHandleType(null_handle)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbsetArrayElement wraps MEOS C function jsonbset_array_element. -func JsonbsetArrayElement(set *Set, idx int, astext bool, null_handle NullHandleType) *Set { +func JsonbsetArrayElement(set *Set, idx int, astext bool, null_handle NullHandleType) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.jsonbset_array_element(set._inner, C.int(idx), C.bool(astext), C.nullHandleType(null_handle)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbsetDeleteIndex wraps MEOS C function jsonbset_delete_index. -func JsonbsetDeleteIndex(set *Set, idx int) *Set { +func JsonbsetDeleteIndex(set *Set, idx int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.jsonbset_delete_index(set._inner, C.int(idx)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbsetDelete wraps MEOS C function jsonbset_delete. -func JsonbsetDelete(set *Set, key string) *Set { +func JsonbsetDelete(set *Set, key string) (_r0 *Set, _err error) { _c_key := C.cstring_to_text(C.CString(key)) defer C.free(unsafe.Pointer(_c_key)) + C.meos_errno_reset() _cret := C.jsonbset_delete(set._inner, _c_key) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbsetDeleteArray wraps MEOS C function jsonbset_delete_array. -func JsonbsetDeleteArray(set *Set, keys unsafe.Pointer, count int) *Set { +func JsonbsetDeleteArray(set *Set, keys unsafe.Pointer, count int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.jsonbset_delete_array(set._inner, (**C.text)(unsafe.Pointer(keys)), C.int(count)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbsetExists wraps MEOS C function jsonbset_exists. -func JsonbsetExists(set *Set, key string, count unsafe.Pointer) unsafe.Pointer { +func JsonbsetExists(set *Set, key string, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { _c_key := C.cstring_to_text(C.CString(key)) defer C.free(unsafe.Pointer(_c_key)) + C.meos_errno_reset() _cret := C.jsonbset_exists(set._inner, _c_key, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // JsonbsetExistsArray wraps MEOS C function jsonbset_exists_array. -func JsonbsetExistsArray(set *Set, keys unsafe.Pointer, count int, any bool, rescount unsafe.Pointer) unsafe.Pointer { +func JsonbsetExistsArray(set *Set, keys unsafe.Pointer, count int, any bool, rescount unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _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) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // JsonbsetSet wraps MEOS C function jsonbset_set. -func JsonbsetSet(set *Set, keys unsafe.Pointer, count int, newjb *Jsonb, create bool, null_handle string, lax bool) *Set { +func JsonbsetSet(set *Set, keys unsafe.Pointer, count int, newjb *Jsonb, create bool, null_handle string, lax bool) (_r0 *Set, _err error) { _c_null_handle := C.cstring_to_text(C.CString(null_handle)) defer C.free(unsafe.Pointer(_c_null_handle)) + C.meos_errno_reset() _cret := C.jsonbset_set(set._inner, (**C.text)(unsafe.Pointer(keys)), C.int(count), newjb._inner, C.bool(create), _c_null_handle, C.bool(lax)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbsetToAlphanumset wraps MEOS C function jsonbset_to_alphanumset. -func JsonbsetToAlphanumset(set *Set, key string, settype MeosType, null_handle NullHandleType) *Set { +func JsonbsetToAlphanumset(set *Set, key string, settype MeosType, null_handle NullHandleType) (_r0 *Set, _err error) { _c_key := C.CString(key) defer C.free(unsafe.Pointer(_c_key)) + C.meos_errno_reset() _cret := C.jsonbset_to_alphanumset(set._inner, _c_key, C.MeosType(settype), C.nullHandleType(null_handle)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbsetToIntset wraps MEOS C function jsonbset_to_intset. -func JsonbsetToIntset(set *Set, key string, null_handle NullHandleType) *Set { +func JsonbsetToIntset(set *Set, key string, null_handle NullHandleType) (_r0 *Set, _err error) { _c_key := C.CString(key) defer C.free(unsafe.Pointer(_c_key)) + C.meos_errno_reset() _cret := C.jsonbset_to_intset(set._inner, _c_key, C.nullHandleType(null_handle)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbsetToBigintset wraps MEOS C function jsonbset_to_bigintset. -func JsonbsetToBigintset(set *Set, key string, null_handle NullHandleType) *Set { +func JsonbsetToBigintset(set *Set, key string, null_handle NullHandleType) (_r0 *Set, _err error) { _c_key := C.CString(key) defer C.free(unsafe.Pointer(_c_key)) + C.meos_errno_reset() _cret := C.jsonbset_to_bigintset(set._inner, _c_key, C.nullHandleType(null_handle)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbsetToFloatset wraps MEOS C function jsonbset_to_floatset. -func JsonbsetToFloatset(set *Set, key string, null_handle NullHandleType) *Set { +func JsonbsetToFloatset(set *Set, key string, null_handle NullHandleType) (_r0 *Set, _err error) { _c_key := C.CString(key) defer C.free(unsafe.Pointer(_c_key)) + C.meos_errno_reset() _cret := C.jsonbset_to_floatset(set._inner, _c_key, C.nullHandleType(null_handle)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbsetToTextsetKey wraps MEOS C function jsonbset_to_textset_key. -func JsonbsetToTextsetKey(set *Set, key string, null_handle NullHandleType) *Set { +func JsonbsetToTextsetKey(set *Set, key string, null_handle NullHandleType) (_r0 *Set, _err error) { _c_key := C.CString(key) defer C.free(unsafe.Pointer(_c_key)) + C.meos_errno_reset() _cret := C.jsonbset_to_textset_key(set._inner, _c_key, C.nullHandleType(null_handle)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbsetStripNulls wraps MEOS C function jsonbset_strip_nulls. -func JsonbsetStripNulls(set *Set, strip_in_arrays bool) *Set { +func JsonbsetStripNulls(set *Set, strip_in_arrays bool) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.jsonbset_strip_nulls(set._inner, C.bool(strip_in_arrays)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbsetPretty wraps MEOS C function jsonbset_pretty. -func JsonbsetPretty(set *Set) *Set { +func JsonbsetPretty(set *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.jsonbset_pretty(set._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbsetDeletePath wraps MEOS C function jsonbset_delete_path. -func JsonbsetDeletePath(set *Set, path_elems unsafe.Pointer, path_len int) *Set { +func JsonbsetDeletePath(set *Set, path_elems unsafe.Pointer, path_len int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.jsonbset_delete_path(set._inner, (**C.text)(unsafe.Pointer(path_elems)), C.int(path_len)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbsetExtractPath wraps MEOS C function jsonbset_extract_path. -func JsonbsetExtractPath(set *Set, path_elems unsafe.Pointer, path_len int, astext bool, null_handle NullHandleType) *Set { +func JsonbsetExtractPath(set *Set, path_elems unsafe.Pointer, path_len int, astext bool, null_handle NullHandleType) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.jsonbset_extract_path(set._inner, (**C.text)(unsafe.Pointer(path_elems)), C.int(path_len), C.bool(astext), C.nullHandleType(null_handle)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbsetInsert wraps MEOS C function jsonbset_insert. -func JsonbsetInsert(set *Set, path_elems unsafe.Pointer, path_len int, newjb *Jsonb, after bool) *Set { +func JsonbsetInsert(set *Set, path_elems unsafe.Pointer, path_len int, newjb *Jsonb, after bool) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.jsonbset_insert(set._inner, (**C.text)(unsafe.Pointer(path_elems)), C.int(path_len), newjb._inner, C.bool(after)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbsetPathExists wraps MEOS C function jsonbset_path_exists. -func JsonbsetPathExists(set *Set, jp *JsonPath, vars *Jsonb, silent bool, tz bool, count unsafe.Pointer) unsafe.Pointer { +func JsonbsetPathExists(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(set._inner, jp._inner, vars._inner, C.bool(silent), C.bool(tz), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // JsonbsetPathMatch wraps MEOS C function jsonbset_path_match. -func JsonbsetPathMatch(set *Set, jp *JsonPath, vars *Jsonb, silent bool, tz bool, count unsafe.Pointer) unsafe.Pointer { +func JsonbsetPathMatch(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(set._inner, jp._inner, vars._inner, C.bool(silent), C.bool(tz), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // JsonbsetPathQueryArray wraps MEOS C function jsonbset_path_query_array. -func JsonbsetPathQueryArray(set *Set, jp *JsonPath, vars *Jsonb, silent bool, tz bool) *Set { +func JsonbsetPathQueryArray(set *Set, jp *JsonPath, vars *Jsonb, silent bool, tz bool) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.jsonbset_path_query_array(set._inner, jp._inner, vars._inner, C.bool(silent), C.bool(tz)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbsetPathQueryFirst wraps MEOS C function jsonbset_path_query_first. -func JsonbsetPathQueryFirst(set *Set, jp *JsonPath, vars *Jsonb, silent bool, tz bool) *Set { +func JsonbsetPathQueryFirst(set *Set, jp *JsonPath, vars *Jsonb, silent bool, tz bool) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.jsonbset_path_query_first(set._inner, jp._inner, vars._inner, C.bool(silent), C.bool(tz)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // ContainedJsonbSet wraps MEOS C function contained_jsonb_set. -func ContainedJsonbSet(jb *Jsonb, s *Set) bool { +func ContainedJsonbSet(jb *Jsonb, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_jsonb_set(jb._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSetJsonb wraps MEOS C function contains_set_jsonb. -func ContainsSetJsonb(s *Set, jb *Jsonb) bool { +func ContainsSetJsonb(s *Set, jb *Jsonb) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_set_jsonb(s._inner, jb._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // IntersectionJsonbSet wraps MEOS C function intersection_jsonb_set. -func IntersectionJsonbSet(jb *Jsonb, s *Set) *Set { +func IntersectionJsonbSet(jb *Jsonb, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_jsonb_set(jb._inner, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntersectionSetJsonb wraps MEOS C function intersection_set_jsonb. -func IntersectionSetJsonb(s *Set, jb *Jsonb) *Set { +func IntersectionSetJsonb(s *Set, jb *Jsonb) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_set_jsonb(s._inner, jb._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // JsonbUnionTransfn wraps MEOS C function jsonb_union_transfn. -func JsonbUnionTransfn(state *Set, jb *Jsonb) *Set { +func JsonbUnionTransfn(state *Set, jb *Jsonb) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.jsonb_union_transfn(state._inner, jb._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusJsonbSet wraps MEOS C function minus_jsonb_set. -func MinusJsonbSet(jb *Jsonb, s *Set) *Set { +func MinusJsonbSet(jb *Jsonb, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_jsonb_set(jb._inner, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusSetJsonb wraps MEOS C function minus_set_jsonb. -func MinusSetJsonb(s *Set, jb *Jsonb) *Set { +func MinusSetJsonb(s *Set, jb *Jsonb) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_set_jsonb(s._inner, jb._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionJsonbSet wraps MEOS C function union_jsonb_set. -func UnionJsonbSet(jb *Jsonb, s *Set) *Set { +func UnionJsonbSet(jb *Jsonb, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_jsonb_set(jb._inner, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionSetJsonb wraps MEOS C function union_set_jsonb. -func UnionSetJsonb(s *Set, jb *Jsonb) *Set { +func UnionSetJsonb(s *Set, jb *Jsonb) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_set_jsonb(s._inner, jb._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TjsonbFromMFJSON wraps MEOS C function tjsonb_from_mfjson. -func TjsonbFromMFJSON(str string) *Temporal { +func TjsonbFromMFJSON(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tjsonb_from_mfjson(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbIn wraps MEOS C function tjsonb_in. -func TjsonbIn(str string) *Temporal { +func TjsonbIn(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tjsonb_in(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbOut wraps MEOS C function tjsonb_out. -func TjsonbOut(temp *Temporal) string { +func TjsonbOut(temp *Temporal) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_out(temp._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TjsonbinstIn wraps MEOS C function tjsonbinst_in. -func TjsonbinstIn(str string) *TInstant { +func TjsonbinstIn(str string) (_r0 *TInstant, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tjsonbinst_in(_c_str) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TjsonbseqIn wraps MEOS C function tjsonbseq_in. -func TjsonbseqIn(str string, interp Interpolation) *TSequence { +func TjsonbseqIn(str string, interp Interpolation) (_r0 *TSequence, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tjsonbseq_in(_c_str, C.interpType(interp)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TjsonbseqsetIn wraps MEOS C function tjsonbseqset_in. -func TjsonbseqsetIn(str string) *TSequenceSet { +func TjsonbseqsetIn(str string) (_r0 *TSequenceSet, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tjsonbseqset_in(_c_str) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TjsonbFromBaseTemp wraps MEOS C function tjsonb_from_base_temp. -func TjsonbFromBaseTemp(jsonb *Jsonb, temp *Temporal) *Temporal { +func TjsonbFromBaseTemp(jsonb *Jsonb, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_from_base_temp(jsonb._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbinstMake wraps MEOS C function tjsonbinst_make. -func TjsonbinstMake(jsonb *Jsonb, t int64) *TInstant { +func TjsonbinstMake(jsonb *Jsonb, t int64) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tjsonbinst_make(jsonb._inner, C.TimestampTz(t)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TjsonbseqFromBaseTstzset wraps MEOS C function tjsonbseq_from_base_tstzset. -func TjsonbseqFromBaseTstzset(jsonb *Jsonb, s *Set) *TSequence { +func TjsonbseqFromBaseTstzset(jsonb *Jsonb, s *Set) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tjsonbseq_from_base_tstzset(jsonb._inner, s._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TjsonbseqFromBaseTstzspan wraps MEOS C function tjsonbseq_from_base_tstzspan. -func TjsonbseqFromBaseTstzspan(jsonb *Jsonb, sp *Span) *TSequence { +func TjsonbseqFromBaseTstzspan(jsonb *Jsonb, sp *Span) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tjsonbseq_from_base_tstzspan(jsonb._inner, sp._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TjsonbseqsetFromBaseTstzspanset wraps MEOS C function tjsonbseqset_from_base_tstzspanset. -func TjsonbseqsetFromBaseTstzspanset(jsonb *Jsonb, ss *SpanSet) *TSequenceSet { +func TjsonbseqsetFromBaseTstzspanset(jsonb *Jsonb, ss *SpanSet) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tjsonbseqset_from_base_tstzspanset(jsonb._inner, ss._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TjsonbToTtext wraps MEOS C function tjsonb_to_ttext. -func TjsonbToTtext(temp *Temporal) *Temporal { +func TjsonbToTtext(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_to_ttext(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TtextToTjsonb wraps MEOS C function ttext_to_tjsonb. -func TtextToTjsonb(temp *Temporal) *Temporal { +func TtextToTjsonb(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.ttext_to_tjsonb(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbEndValue wraps MEOS C function tjsonb_end_value. -func TjsonbEndValue(temp *Temporal) *Jsonb { +func TjsonbEndValue(temp *Temporal) (_r0 *Jsonb, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_end_value(temp._inner) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // TjsonbStartValue wraps MEOS C function tjsonb_start_value. -func TjsonbStartValue(temp *Temporal) *Jsonb { +func TjsonbStartValue(temp *Temporal) (_r0 *Jsonb, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_start_value(temp._inner) - return &Jsonb{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Jsonb{_inner: _cret}, nil } // TjsonbValueAtTimestamptz wraps MEOS C function tjsonb_value_at_timestamptz. -func TjsonbValueAtTimestamptz(temp *Temporal, t int64, strict bool) (bool, *Jsonb) { +func TjsonbValueAtTimestamptz(temp *Temporal, t int64, strict bool) (_r0 bool, _r1 *Jsonb, _err error) { var _out_value *C.Jsonb + C.meos_errno_reset() _cret := C.tjsonb_value_at_timestamptz(temp._inner, C.TimestampTz(t), C.bool(strict), &_out_value) - return bool(_cret), &Jsonb{_inner: _out_value} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Jsonb{_inner: _out_value}, nil } // TjsonbValueN wraps MEOS C function tjsonb_value_n. -func TjsonbValueN(temp *Temporal, n int) (bool, *Jsonb) { +func TjsonbValueN(temp *Temporal, n int) (_r0 bool, _r1 *Jsonb, _err error) { var _out_result *C.Jsonb + C.meos_errno_reset() _cret := C.tjsonb_value_n(temp._inner, C.int(n), &_out_result) - return bool(_cret), &Jsonb{_inner: _out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Jsonb{_inner: _out_result}, nil } // TjsonbValues wraps MEOS C function tjsonb_values. -func TjsonbValues(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TjsonbValues(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_values(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // ConcatTjsonbJsonb wraps MEOS C function concat_tjsonb_jsonb. -func ConcatTjsonbJsonb(temp *Temporal, jb *Jsonb, invert bool) *Temporal { +func ConcatTjsonbJsonb(temp *Temporal, jb *Jsonb, invert bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.concat_tjsonb_jsonb(temp._inner, jb._inner, C.bool(invert)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // ConcatTjsonbTjsonb wraps MEOS C function concat_tjsonb_tjsonb. -func ConcatTjsonbTjsonb(temp1 *Temporal, temp2 *Temporal) *Temporal { +func ConcatTjsonbTjsonb(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.concat_tjsonb_tjsonb(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // ContainsTjsonbJsonb wraps MEOS C function contains_tjsonb_jsonb. -func ContainsTjsonbJsonb(temp *Temporal, jb *Jsonb, invert bool) *Temporal { +func ContainsTjsonbJsonb(temp *Temporal, jb *Jsonb, invert bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.contains_tjsonb_jsonb(temp._inner, jb._inner, C.bool(invert)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // ContainsTjsonbTjsonb wraps MEOS C function contains_tjsonb_tjsonb. -func ContainsTjsonbTjsonb(temp1 *Temporal, temp2 *Temporal) *Temporal { +func ContainsTjsonbTjsonb(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.contains_tjsonb_tjsonb(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // NullHandleTypeFromString wraps MEOS C function null_handle_type_from_string. -func NullHandleTypeFromString(str string) NullHandleType { +func NullHandleTypeFromString(str string) (_r0 NullHandleType, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.null_handle_type_from_string(_c_str) - return NullHandleType(_cret) + if _err = meosError(); _err != nil { + return + } + return NullHandleType(_cret), nil } // TjsonArrayElement wraps MEOS C function tjson_array_element. -func TjsonArrayElement(temp *Temporal, idx int, null_handle NullHandleType) *Temporal { +func TjsonArrayElement(temp *Temporal, idx int, null_handle NullHandleType) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjson_array_element(temp._inner, C.int(idx), C.nullHandleType(null_handle)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonArrayLength wraps MEOS C function tjson_array_length. -func TjsonArrayLength(temp *Temporal) *Temporal { +func TjsonArrayLength(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjson_array_length(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonExtractPath wraps MEOS C function tjson_extract_path. -func TjsonExtractPath(temp *Temporal, path_elems unsafe.Pointer, path_len int, null_handle NullHandleType) *Temporal { +func TjsonExtractPath(temp *Temporal, path_elems unsafe.Pointer, path_len int, null_handle NullHandleType) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjson_extract_path(temp._inner, (**C.text)(unsafe.Pointer(path_elems)), C.int(path_len), C.nullHandleType(null_handle)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonObjectField wraps MEOS C function tjson_object_field. -func TjsonObjectField(temp *Temporal, key string, astext bool, null_handle NullHandleType) *Temporal { +func TjsonObjectField(temp *Temporal, key string, astext bool, null_handle NullHandleType) (_r0 *Temporal, _err error) { _c_key := C.cstring_to_text(C.CString(key)) defer C.free(unsafe.Pointer(_c_key)) + C.meos_errno_reset() _cret := C.tjson_object_field(temp._inner, _c_key, C.bool(astext), C.nullHandleType(null_handle)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonStripNulls wraps MEOS C function tjson_strip_nulls. -func TjsonStripNulls(temp *Temporal, strip_in_arrays bool) *Temporal { +func TjsonStripNulls(temp *Temporal, strip_in_arrays bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjson_strip_nulls(temp._inner, C.bool(strip_in_arrays)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbArrayElement wraps MEOS C function tjsonb_array_element. -func TjsonbArrayElement(temp *Temporal, idx int, astext bool, null_handle NullHandleType) *Temporal { +func TjsonbArrayElement(temp *Temporal, idx int, astext bool, null_handle NullHandleType) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_array_element(temp._inner, C.int(idx), C.bool(astext), C.nullHandleType(null_handle)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbArrayLength wraps MEOS C function tjsonb_array_length. -func TjsonbArrayLength(temp *Temporal) *Temporal { +func TjsonbArrayLength(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_array_length(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbDelete wraps MEOS C function tjsonb_delete. -func TjsonbDelete(temp *Temporal, key string) *Temporal { +func TjsonbDelete(temp *Temporal, key string) (_r0 *Temporal, _err error) { _c_key := C.cstring_to_text(C.CString(key)) defer C.free(unsafe.Pointer(_c_key)) + C.meos_errno_reset() _cret := C.tjsonb_delete(temp._inner, _c_key) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbDeleteArray wraps MEOS C function tjsonb_delete_array. -func TjsonbDeleteArray(temp *Temporal, keys unsafe.Pointer, count int) *Temporal { +func TjsonbDeleteArray(temp *Temporal, keys unsafe.Pointer, count int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_delete_array(temp._inner, (**C.text)(unsafe.Pointer(keys)), C.int(count)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbDeleteIndex wraps MEOS C function tjsonb_delete_index. -func TjsonbDeleteIndex(temp *Temporal, idx int) *Temporal { +func TjsonbDeleteIndex(temp *Temporal, idx int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_delete_index(temp._inner, C.int(idx)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbDeletePath wraps MEOS C function tjsonb_delete_path. -func TjsonbDeletePath(temp *Temporal, path_elems unsafe.Pointer, path_len int) *Temporal { +func TjsonbDeletePath(temp *Temporal, path_elems unsafe.Pointer, path_len int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_delete_path(temp._inner, (**C.text)(unsafe.Pointer(path_elems)), C.int(path_len)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbExists wraps MEOS C function tjsonb_exists. -func TjsonbExists(temp *Temporal, key string) *Temporal { +func TjsonbExists(temp *Temporal, key string) (_r0 *Temporal, _err error) { _c_key := C.cstring_to_text(C.CString(key)) defer C.free(unsafe.Pointer(_c_key)) + C.meos_errno_reset() _cret := C.tjsonb_exists(temp._inner, _c_key) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbExistsAll wraps MEOS C function tjsonb_exists_all. -func TjsonbExistsAll(temp *Temporal, keys unsafe.Pointer, count int) *Temporal { +func TjsonbExistsAll(temp *Temporal, keys unsafe.Pointer, count int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_exists_all(temp._inner, (**C.text)(unsafe.Pointer(keys)), C.int(count)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbExistsAny wraps MEOS C function tjsonb_exists_any. -func TjsonbExistsAny(temp *Temporal, keys unsafe.Pointer, count int) *Temporal { +func TjsonbExistsAny(temp *Temporal, keys unsafe.Pointer, count int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_exists_any(temp._inner, (**C.text)(unsafe.Pointer(keys)), C.int(count)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbExistsArray wraps MEOS C function tjsonb_exists_array. -func TjsonbExistsArray(temp *Temporal, keys unsafe.Pointer, count int, any bool) *Temporal { +func TjsonbExistsArray(temp *Temporal, keys unsafe.Pointer, count int, any bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_exists_array(temp._inner, (**C.text)(unsafe.Pointer(keys)), C.int(count), C.bool(any)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbExtractPath wraps MEOS C function tjsonb_extract_path. -func TjsonbExtractPath(temp *Temporal, path_elems unsafe.Pointer, path_len int, astext bool, null_handle NullHandleType) *Temporal { +func TjsonbExtractPath(temp *Temporal, path_elems unsafe.Pointer, path_len int, astext bool, null_handle NullHandleType) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_extract_path(temp._inner, (**C.text)(unsafe.Pointer(path_elems)), C.int(path_len), C.bool(astext), C.nullHandleType(null_handle)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbInsert wraps MEOS C function tjsonb_insert. -func TjsonbInsert(temp *Temporal, keys unsafe.Pointer, count int, newjb *Jsonb, after bool) *Temporal { +func TjsonbInsert(temp *Temporal, keys unsafe.Pointer, count int, newjb *Jsonb, after bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_insert(temp._inner, (**C.text)(unsafe.Pointer(keys)), C.int(count), newjb._inner, C.bool(after)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbObjectField wraps MEOS C function tjsonb_object_field. -func TjsonbObjectField(temp *Temporal, key string, astext bool, null_handle NullHandleType) *Temporal { +func TjsonbObjectField(temp *Temporal, key string, astext bool, null_handle NullHandleType) (_r0 *Temporal, _err error) { _c_key := C.cstring_to_text(C.CString(key)) defer C.free(unsafe.Pointer(_c_key)) + C.meos_errno_reset() _cret := C.tjsonb_object_field(temp._inner, _c_key, C.bool(astext), C.nullHandleType(null_handle)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbPathExists wraps MEOS C function tjsonb_path_exists. -func TjsonbPathExists(temp *Temporal, jp *JsonPath, vars *Jsonb, silent bool, tz bool) *Temporal { +func TjsonbPathExists(temp *Temporal, jp *JsonPath, vars *Jsonb, silent bool, tz bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_path_exists(temp._inner, jp._inner, vars._inner, C.bool(silent), C.bool(tz)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbPathMatch wraps MEOS C function tjsonb_path_match. -func TjsonbPathMatch(temp *Temporal, jp *JsonPath, vars *Jsonb, silent bool, tz bool) *Temporal { +func TjsonbPathMatch(temp *Temporal, jp *JsonPath, vars *Jsonb, silent bool, tz bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_path_match(temp._inner, jp._inner, vars._inner, C.bool(silent), C.bool(tz)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbPathQueryArray wraps MEOS C function tjsonb_path_query_array. -func TjsonbPathQueryArray(temp *Temporal, jp *JsonPath, vars *Jsonb, silent bool, tz bool) *Temporal { +func TjsonbPathQueryArray(temp *Temporal, jp *JsonPath, vars *Jsonb, silent bool, tz bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_path_query_array(temp._inner, jp._inner, vars._inner, C.bool(silent), C.bool(tz)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbPathQueryFirst wraps MEOS C function tjsonb_path_query_first. -func TjsonbPathQueryFirst(temp *Temporal, jp *JsonPath, vars *Jsonb, silent bool, tz bool) *Temporal { +func TjsonbPathQueryFirst(temp *Temporal, jp *JsonPath, vars *Jsonb, silent bool, tz bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_path_query_first(temp._inner, jp._inner, vars._inner, C.bool(silent), C.bool(tz)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbPretty wraps MEOS C function tjsonb_pretty. -func TjsonbPretty(temp *Temporal) *Temporal { +func TjsonbPretty(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_pretty(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbSet wraps MEOS C function tjsonb_set. -func TjsonbSet(temp *Temporal, keys unsafe.Pointer, count int, newjb *Jsonb, create bool, handle_null string, lax bool) *Temporal { +func TjsonbSet(temp *Temporal, keys unsafe.Pointer, count int, newjb *Jsonb, create bool, handle_null string, lax bool) (_r0 *Temporal, _err error) { _c_handle_null := C.cstring_to_text(C.CString(handle_null)) defer C.free(unsafe.Pointer(_c_handle_null)) + C.meos_errno_reset() _cret := C.tjsonb_set(temp._inner, (**C.text)(unsafe.Pointer(keys)), C.int(count), newjb._inner, C.bool(create), _c_handle_null, C.bool(lax)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbStripNulls wraps MEOS C function tjsonb_strip_nulls. -func TjsonbStripNulls(temp *Temporal, strip_in_arrays bool) *Temporal { +func TjsonbStripNulls(temp *Temporal, strip_in_arrays bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_strip_nulls(temp._inner, C.bool(strip_in_arrays)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbToTbool wraps MEOS C function tjsonb_to_tbool. -func TjsonbToTbool(temp *Temporal, key string, null_handle NullHandleType) *Temporal { +func TjsonbToTbool(temp *Temporal, key string, null_handle NullHandleType) (_r0 *Temporal, _err error) { _c_key := C.CString(key) defer C.free(unsafe.Pointer(_c_key)) + C.meos_errno_reset() _cret := C.tjsonb_to_tbool(temp._inner, _c_key, C.nullHandleType(null_handle)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbToTfloat wraps MEOS C function tjsonb_to_tfloat. -func TjsonbToTfloat(temp *Temporal, key string, interp Interpolation, null_handle NullHandleType) *Temporal { +func TjsonbToTfloat(temp *Temporal, key string, interp Interpolation, null_handle NullHandleType) (_r0 *Temporal, _err error) { _c_key := C.CString(key) defer C.free(unsafe.Pointer(_c_key)) + C.meos_errno_reset() _cret := C.tjsonb_to_tfloat(temp._inner, _c_key, C.interpType(interp), C.nullHandleType(null_handle)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbToTint wraps MEOS C function tjsonb_to_tint. -func TjsonbToTint(temp *Temporal, key string, null_handle NullHandleType) *Temporal { +func TjsonbToTint(temp *Temporal, key string, null_handle NullHandleType) (_r0 *Temporal, _err error) { _c_key := C.CString(key) defer C.free(unsafe.Pointer(_c_key)) + C.meos_errno_reset() _cret := C.tjsonb_to_tint(temp._inner, _c_key, C.nullHandleType(null_handle)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbToTtextKey wraps MEOS C function tjsonb_to_ttext_key. -func TjsonbToTtextKey(temp *Temporal, key string, null_handle NullHandleType) *Temporal { +func TjsonbToTtextKey(temp *Temporal, key string, null_handle NullHandleType) (_r0 *Temporal, _err error) { _c_key := C.CString(key) defer C.free(unsafe.Pointer(_c_key)) + C.meos_errno_reset() _cret := C.tjsonb_to_ttext_key(temp._inner, _c_key, C.nullHandleType(null_handle)) - return &Temporal{_inner: _cret} + 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) *Temporal { +func TjsonbAtValue(temp *Temporal, jsb *Jsonb) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_at_value(temp._inner, jsb._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TjsonbMinusValue wraps MEOS C function tjsonb_minus_value. -func TjsonbMinusValue(temp *Temporal, jsb *Jsonb) *Temporal { +func TjsonbMinusValue(temp *Temporal, jsb *Jsonb) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tjsonb_minus_value(temp._inner, jsb._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // AlwaysEqJsonbTjsonb wraps MEOS C function always_eq_jsonb_tjsonb. -func AlwaysEqJsonbTjsonb(jb *Jsonb, temp *Temporal) int { +func AlwaysEqJsonbTjsonb(jb *Jsonb, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_jsonb_tjsonb(jb._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTjsonbJsonb wraps MEOS C function always_eq_tjsonb_jsonb. -func AlwaysEqTjsonbJsonb(temp *Temporal, jb *Jsonb) int { +func AlwaysEqTjsonbJsonb(temp *Temporal, jb *Jsonb) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_tjsonb_jsonb(temp._inner, jb._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTjsonbTjsonb wraps MEOS C function always_eq_tjsonb_tjsonb. -func AlwaysEqTjsonbTjsonb(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysEqTjsonbTjsonb(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_tjsonb_tjsonb(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeJsonbTjsonb wraps MEOS C function always_ne_jsonb_tjsonb. -func AlwaysNeJsonbTjsonb(jb *Jsonb, temp *Temporal) int { +func AlwaysNeJsonbTjsonb(jb *Jsonb, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_jsonb_tjsonb(jb._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTjsonbJsonb wraps MEOS C function always_ne_tjsonb_jsonb. -func AlwaysNeTjsonbJsonb(temp *Temporal, jb *Jsonb) int { +func AlwaysNeTjsonbJsonb(temp *Temporal, jb *Jsonb) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_tjsonb_jsonb(temp._inner, jb._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTjsonbTjsonb wraps MEOS C function always_ne_tjsonb_tjsonb. -func AlwaysNeTjsonbTjsonb(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysNeTjsonbTjsonb(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_tjsonb_tjsonb(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqJsonbTjsonb wraps MEOS C function ever_eq_jsonb_tjsonb. -func EverEqJsonbTjsonb(jb *Jsonb, temp *Temporal) int { +func EverEqJsonbTjsonb(jb *Jsonb, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_jsonb_tjsonb(jb._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTjsonbJsonb wraps MEOS C function ever_eq_tjsonb_jsonb. -func EverEqTjsonbJsonb(temp *Temporal, jb *Jsonb) int { +func EverEqTjsonbJsonb(temp *Temporal, jb *Jsonb) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_tjsonb_jsonb(temp._inner, jb._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTjsonbTjsonb wraps MEOS C function ever_eq_tjsonb_tjsonb. -func EverEqTjsonbTjsonb(temp1 *Temporal, temp2 *Temporal) int { +func EverEqTjsonbTjsonb(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_tjsonb_tjsonb(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeJsonbTjsonb wraps MEOS C function ever_ne_jsonb_tjsonb. -func EverNeJsonbTjsonb(jb *Jsonb, temp *Temporal) int { +func EverNeJsonbTjsonb(jb *Jsonb, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_jsonb_tjsonb(jb._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTjsonbJsonb wraps MEOS C function ever_ne_tjsonb_jsonb. -func EverNeTjsonbJsonb(temp *Temporal, jb *Jsonb) int { +func EverNeTjsonbJsonb(temp *Temporal, jb *Jsonb) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_tjsonb_jsonb(temp._inner, jb._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTjsonbTjsonb wraps MEOS C function ever_ne_tjsonb_tjsonb. -func EverNeTjsonbTjsonb(temp1 *Temporal, temp2 *Temporal) int { +func EverNeTjsonbTjsonb(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_tjsonb_tjsonb(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TeqJsonbTjsonb wraps MEOS C function teq_jsonb_tjsonb. -func TeqJsonbTjsonb(jb *Jsonb, temp *Temporal) *Temporal { +func TeqJsonbTjsonb(jb *Jsonb, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_jsonb_tjsonb(jb._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TeqTjsonbJsonb wraps MEOS C function teq_tjsonb_jsonb. -func TeqTjsonbJsonb(temp *Temporal, jb *Jsonb) *Temporal { +func TeqTjsonbJsonb(temp *Temporal, jb *Jsonb) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_tjsonb_jsonb(temp._inner, jb._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneJsonbTjsonb wraps MEOS C function tne_jsonb_tjsonb. -func TneJsonbTjsonb(jb *Jsonb, temp *Temporal) *Temporal { +func TneJsonbTjsonb(jb *Jsonb, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_jsonb_tjsonb(jb._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneTjsonbJsonb wraps MEOS C function tne_tjsonb_jsonb. -func TneTjsonbJsonb(temp *Temporal, jb *Jsonb) *Temporal { +func TneTjsonbJsonb(temp *Temporal, jb *Jsonb) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_tjsonb_jsonb(temp._inner, jb._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } diff --git a/functions/meos_meos_npoint.go b/functions/meos_meos_npoint.go index 064c4db..d541c61 100644 --- a/functions/meos_meos_npoint.go +++ b/functions/meos_meos_npoint.go @@ -86,912 +86,1424 @@ import ( var _ = unsafe.Pointer(nil) // NpointAsEWKT wraps MEOS C function npoint_as_ewkt. -func NpointAsEWKT(np *Npoint, maxdd int) string { +func NpointAsEWKT(np *Npoint, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.npoint_as_ewkt(np._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // NpointAsHexwkb wraps MEOS C function npoint_as_hexwkb. -func NpointAsHexwkb(np *Npoint, variant uint8, size_out unsafe.Pointer) string { +func NpointAsHexwkb(np *Npoint, variant uint8, size_out unsafe.Pointer) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.npoint_as_hexwkb(np._inner, C.uint8_t(variant), (*C.size_t)(unsafe.Pointer(size_out))) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // NpointAsText wraps MEOS C function npoint_as_text. -func NpointAsText(np *Npoint, maxdd int) string { +func NpointAsText(np *Npoint, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.npoint_as_text(np._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // NpointAsWKB wraps MEOS C function npoint_as_wkb. -func NpointAsWKB(np *Npoint, variant uint8, size_out unsafe.Pointer) unsafe.Pointer { +func NpointAsWKB(np *Npoint, variant uint8, size_out unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.npoint_as_wkb(np._inner, C.uint8_t(variant), (*C.size_t)(unsafe.Pointer(size_out))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // NpointFromHexwkb wraps MEOS C function npoint_from_hexwkb. -func NpointFromHexwkb(hexwkb string) *Npoint { +func NpointFromHexwkb(hexwkb string) (_r0 *Npoint, _err error) { _c_hexwkb := C.CString(hexwkb) defer C.free(unsafe.Pointer(_c_hexwkb)) + C.meos_errno_reset() _cret := C.npoint_from_hexwkb(_c_hexwkb) - return &Npoint{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Npoint{_inner: _cret}, nil } // NpointFromWKB wraps MEOS C function npoint_from_wkb. -func NpointFromWKB(wkb unsafe.Pointer, size uint) *Npoint { +func NpointFromWKB(wkb unsafe.Pointer, size uint) (_r0 *Npoint, _err error) { + C.meos_errno_reset() _cret := C.npoint_from_wkb((*C.uint8_t)(unsafe.Pointer(wkb)), C.size_t(size)) - return &Npoint{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Npoint{_inner: _cret}, nil } // NpointIn wraps MEOS C function npoint_in. -func NpointIn(str string) *Npoint { +func NpointIn(str string) (_r0 *Npoint, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.npoint_in(_c_str) - return &Npoint{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Npoint{_inner: _cret}, nil } // NpointOut wraps MEOS C function npoint_out. -func NpointOut(np *Npoint, maxdd int) string { +func NpointOut(np *Npoint, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.npoint_out(np._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // NsegmentIn wraps MEOS C function nsegment_in. -func NsegmentIn(str string) *Nsegment { +func NsegmentIn(str string) (_r0 *Nsegment, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.nsegment_in(_c_str) - return &Nsegment{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Nsegment{_inner: _cret}, nil } // NsegmentOut wraps MEOS C function nsegment_out. -func NsegmentOut(ns *Nsegment, maxdd int) string { +func NsegmentOut(ns *Nsegment, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.nsegment_out(ns._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // NpointMake wraps MEOS C function npoint_make. -func NpointMake(rid int64, pos float64) *Npoint { +func NpointMake(rid int64, pos float64) (_r0 *Npoint, _err error) { + C.meos_errno_reset() _cret := C.npoint_make(C.int64_t(rid), C.double(pos)) - return &Npoint{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Npoint{_inner: _cret}, nil } // NsegmentMake wraps MEOS C function nsegment_make. -func NsegmentMake(rid int64, pos1 float64, pos2 float64) *Nsegment { +func NsegmentMake(rid int64, pos1 float64, pos2 float64) (_r0 *Nsegment, _err error) { + C.meos_errno_reset() _cret := C.nsegment_make(C.int64_t(rid), C.double(pos1), C.double(pos2)) - return &Nsegment{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Nsegment{_inner: _cret}, nil } // GeompointToNpoint wraps MEOS C function geompoint_to_npoint. -func GeompointToNpoint(gs *Geom) *Npoint { +func GeompointToNpoint(gs *Geom) (_r0 *Npoint, _err error) { + C.meos_errno_reset() _cret := C.geompoint_to_npoint(gs._inner) - return &Npoint{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Npoint{_inner: _cret}, nil } // GeomToNsegment wraps MEOS C function geom_to_nsegment. -func GeomToNsegment(gs *Geom) *Nsegment { +func GeomToNsegment(gs *Geom) (_r0 *Nsegment, _err error) { + C.meos_errno_reset() _cret := C.geom_to_nsegment(gs._inner) - return &Nsegment{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Nsegment{_inner: _cret}, nil } // NpointToGeompoint wraps MEOS C function npoint_to_geompoint. -func NpointToGeompoint(np *Npoint) *Geom { +func NpointToGeompoint(np *Npoint) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.npoint_to_geompoint(np._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // NpointToNsegment wraps MEOS C function npoint_to_nsegment. -func NpointToNsegment(np *Npoint) *Nsegment { +func NpointToNsegment(np *Npoint) (_r0 *Nsegment, _err error) { + C.meos_errno_reset() _cret := C.npoint_to_nsegment(np._inner) - return &Nsegment{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Nsegment{_inner: _cret}, nil } // NpointToSTBOX wraps MEOS C function npoint_to_stbox. -func NpointToSTBOX(np *Npoint) *STBox { +func NpointToSTBOX(np *Npoint) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.npoint_to_stbox(np._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // NsegmentToGeom wraps MEOS C function nsegment_to_geom. -func NsegmentToGeom(ns *Nsegment) *Geom { +func NsegmentToGeom(ns *Nsegment) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.nsegment_to_geom(ns._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // NsegmentToSTBOX wraps MEOS C function nsegment_to_stbox. -func NsegmentToSTBOX(ns *Nsegment) *STBox { +func NsegmentToSTBOX(ns *Nsegment) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.nsegment_to_stbox(ns._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // NpointHash wraps MEOS C function npoint_hash. -func NpointHash(np *Npoint) uint32 { +func NpointHash(np *Npoint) (_r0 uint32, _err error) { + C.meos_errno_reset() _cret := C.npoint_hash(np._inner) - return uint32(_cret) + if _err = meosError(); _err != nil { + return + } + return uint32(_cret), nil } // NpointHashExtended wraps MEOS C function npoint_hash_extended. -func NpointHashExtended(np *Npoint, seed uint64) uint64 { +func NpointHashExtended(np *Npoint, seed uint64) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.npoint_hash_extended(np._inner, C.uint64_t(seed)) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // NpointPosition wraps MEOS C function npoint_position. -func NpointPosition(np *Npoint) float64 { +func NpointPosition(np *Npoint) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.npoint_position(np._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NpointRoute wraps MEOS C function npoint_route. -func NpointRoute(np *Npoint) int64 { +func NpointRoute(np *Npoint) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.npoint_route(np._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // NsegmentEndPosition wraps MEOS C function nsegment_end_position. -func NsegmentEndPosition(ns *Nsegment) float64 { +func NsegmentEndPosition(ns *Nsegment) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nsegment_end_position(ns._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NsegmentRoute wraps MEOS C function nsegment_route. -func NsegmentRoute(ns *Nsegment) int64 { +func NsegmentRoute(ns *Nsegment) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.nsegment_route(ns._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // NsegmentStartPosition wraps MEOS C function nsegment_start_position. -func NsegmentStartPosition(ns *Nsegment) float64 { +func NsegmentStartPosition(ns *Nsegment) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nsegment_start_position(ns._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // RouteExists wraps MEOS C function route_exists. -func RouteExists(rid int64) bool { +func RouteExists(rid int64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.route_exists(C.int64_t(rid)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RouteGeom wraps MEOS C function route_geom. -func RouteGeom(rid int64) *Geom { +func RouteGeom(rid int64) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.route_geom(C.int64_t(rid)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // RouteLength wraps MEOS C function route_length. -func RouteLength(rid int64) float64 { +func RouteLength(rid int64) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.route_length(C.int64_t(rid)) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NpointRound wraps MEOS C function npoint_round. -func NpointRound(np *Npoint, maxdd int) *Npoint { +func NpointRound(np *Npoint, maxdd int) (_r0 *Npoint, _err error) { + C.meos_errno_reset() _cret := C.npoint_round(np._inner, C.int(maxdd)) - return &Npoint{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Npoint{_inner: _cret}, nil } // NsegmentRound wraps MEOS C function nsegment_round. -func NsegmentRound(ns *Nsegment, maxdd int) *Nsegment { +func NsegmentRound(ns *Nsegment, maxdd int) (_r0 *Nsegment, _err error) { + C.meos_errno_reset() _cret := C.nsegment_round(ns._inner, C.int(maxdd)) - return &Nsegment{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Nsegment{_inner: _cret}, nil } // GetSRIDWays wraps MEOS C function get_srid_ways. -func GetSRIDWays() int32 { +func GetSRIDWays() (_r0 int32, _err error) { + C.meos_errno_reset() _cret := C.get_srid_ways() - return int32(_cret) + if _err = meosError(); _err != nil { + return + } + return int32(_cret), nil } // NpointSRID wraps MEOS C function npoint_srid. -func NpointSRID(np *Npoint) int32 { +func NpointSRID(np *Npoint) (_r0 int32, _err error) { + C.meos_errno_reset() _cret := C.npoint_srid(np._inner) - return int32(_cret) + if _err = meosError(); _err != nil { + return + } + return int32(_cret), nil } // NsegmentSRID wraps MEOS C function nsegment_srid. -func NsegmentSRID(ns *Nsegment) int32 { +func NsegmentSRID(ns *Nsegment) (_r0 int32, _err error) { + C.meos_errno_reset() _cret := C.nsegment_srid(ns._inner) - return int32(_cret) + if _err = meosError(); _err != nil { + return + } + return int32(_cret), nil } // NpointTimestamptzToSTBOX wraps MEOS C function npoint_timestamptz_to_stbox. -func NpointTimestamptzToSTBOX(np *Npoint, t int64) *STBox { +func NpointTimestamptzToSTBOX(np *Npoint, t int64) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.npoint_timestamptz_to_stbox(np._inner, C.TimestampTz(t)) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // NpointTstzspanToSTBOX wraps MEOS C function npoint_tstzspan_to_stbox. -func NpointTstzspanToSTBOX(np *Npoint, s *Span) *STBox { +func NpointTstzspanToSTBOX(np *Npoint, s *Span) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.npoint_tstzspan_to_stbox(np._inner, s._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // NpointCmp wraps MEOS C function npoint_cmp. -func NpointCmp(np1 *Npoint, np2 *Npoint) int { +func NpointCmp(np1 *Npoint, np2 *Npoint) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.npoint_cmp(np1._inner, np2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // NpointEq wraps MEOS C function npoint_eq. -func NpointEq(np1 *Npoint, np2 *Npoint) bool { +func NpointEq(np1 *Npoint, np2 *Npoint) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.npoint_eq(np1._inner, np2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // NpointGe wraps MEOS C function npoint_ge. -func NpointGe(np1 *Npoint, np2 *Npoint) bool { +func NpointGe(np1 *Npoint, np2 *Npoint) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.npoint_ge(np1._inner, np2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // NpointGt wraps MEOS C function npoint_gt. -func NpointGt(np1 *Npoint, np2 *Npoint) bool { +func NpointGt(np1 *Npoint, np2 *Npoint) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.npoint_gt(np1._inner, np2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // NpointLe wraps MEOS C function npoint_le. -func NpointLe(np1 *Npoint, np2 *Npoint) bool { +func NpointLe(np1 *Npoint, np2 *Npoint) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.npoint_le(np1._inner, np2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // NpointLt wraps MEOS C function npoint_lt. -func NpointLt(np1 *Npoint, np2 *Npoint) bool { +func NpointLt(np1 *Npoint, np2 *Npoint) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.npoint_lt(np1._inner, np2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // NpointNe wraps MEOS C function npoint_ne. -func NpointNe(np1 *Npoint, np2 *Npoint) bool { +func NpointNe(np1 *Npoint, np2 *Npoint) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.npoint_ne(np1._inner, np2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // NpointSame wraps MEOS C function npoint_same. -func NpointSame(np1 *Npoint, np2 *Npoint) bool { +func NpointSame(np1 *Npoint, np2 *Npoint) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.npoint_same(np1._inner, np2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // NsegmentCmp wraps MEOS C function nsegment_cmp. -func NsegmentCmp(ns1 *Nsegment, ns2 *Nsegment) int { +func NsegmentCmp(ns1 *Nsegment, ns2 *Nsegment) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.nsegment_cmp(ns1._inner, ns2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // NsegmentEq wraps MEOS C function nsegment_eq. -func NsegmentEq(ns1 *Nsegment, ns2 *Nsegment) bool { +func NsegmentEq(ns1 *Nsegment, ns2 *Nsegment) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.nsegment_eq(ns1._inner, ns2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // NsegmentGe wraps MEOS C function nsegment_ge. -func NsegmentGe(ns1 *Nsegment, ns2 *Nsegment) bool { +func NsegmentGe(ns1 *Nsegment, ns2 *Nsegment) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.nsegment_ge(ns1._inner, ns2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // NsegmentGt wraps MEOS C function nsegment_gt. -func NsegmentGt(ns1 *Nsegment, ns2 *Nsegment) bool { +func NsegmentGt(ns1 *Nsegment, ns2 *Nsegment) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.nsegment_gt(ns1._inner, ns2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // NsegmentLe wraps MEOS C function nsegment_le. -func NsegmentLe(ns1 *Nsegment, ns2 *Nsegment) bool { +func NsegmentLe(ns1 *Nsegment, ns2 *Nsegment) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.nsegment_le(ns1._inner, ns2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // NsegmentLt wraps MEOS C function nsegment_lt. -func NsegmentLt(ns1 *Nsegment, ns2 *Nsegment) bool { +func NsegmentLt(ns1 *Nsegment, ns2 *Nsegment) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.nsegment_lt(ns1._inner, ns2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // NsegmentNe wraps MEOS C function nsegment_ne. -func NsegmentNe(ns1 *Nsegment, ns2 *Nsegment) bool { +func NsegmentNe(ns1 *Nsegment, ns2 *Nsegment) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.nsegment_ne(ns1._inner, ns2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // NpointsetIn wraps MEOS C function npointset_in. -func NpointsetIn(str string) *Set { +func NpointsetIn(str string) (_r0 *Set, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.npointset_in(_c_str) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // NpointsetOut wraps MEOS C function npointset_out. -func NpointsetOut(s *Set, maxdd int) string { +func NpointsetOut(s *Set, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.npointset_out(s._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // NpointsetMake wraps MEOS C function npointset_make. -func NpointsetMake(values unsafe.Pointer, count int) *Set { +func NpointsetMake(values unsafe.Pointer, count int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.npointset_make((**C.Npoint)(unsafe.Pointer(values)), C.int(count)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // NpointToSet wraps MEOS C function npoint_to_set. -func NpointToSet(np *Npoint) *Set { +func NpointToSet(np *Npoint) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.npoint_to_set(np._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // NpointsetEndValue wraps MEOS C function npointset_end_value. -func NpointsetEndValue(s *Set) *Npoint { +func NpointsetEndValue(s *Set) (_r0 *Npoint, _err error) { + C.meos_errno_reset() _cret := C.npointset_end_value(s._inner) - return &Npoint{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Npoint{_inner: _cret}, nil } // NpointsetRoutes wraps MEOS C function npointset_routes. -func NpointsetRoutes(s *Set) *Set { +func NpointsetRoutes(s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.npointset_routes(s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // NpointsetStartValue wraps MEOS C function npointset_start_value. -func NpointsetStartValue(s *Set) *Npoint { +func NpointsetStartValue(s *Set) (_r0 *Npoint, _err error) { + C.meos_errno_reset() _cret := C.npointset_start_value(s._inner) - return &Npoint{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Npoint{_inner: _cret}, nil } // NpointsetValueN wraps MEOS C function npointset_value_n. -func NpointsetValueN(s *Set, n int) (bool, *Npoint) { +func NpointsetValueN(s *Set, n int) (_r0 bool, _r1 *Npoint, _err error) { var _out_result *C.Npoint + C.meos_errno_reset() _cret := C.npointset_value_n(s._inner, C.int(n), &_out_result) - return bool(_cret), &Npoint{_inner: _out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Npoint{_inner: _out_result}, nil } // NpointsetValues wraps MEOS C function npointset_values. -func NpointsetValues(s *Set, count unsafe.Pointer) unsafe.Pointer { +func NpointsetValues(s *Set, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.npointset_values(s._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // ContainedNpointSet wraps MEOS C function contained_npoint_set. -func ContainedNpointSet(np *Npoint, s *Set) bool { +func ContainedNpointSet(np *Npoint, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_npoint_set(np._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSetNpoint wraps MEOS C function contains_set_npoint. -func ContainsSetNpoint(s *Set, np *Npoint) bool { +func ContainsSetNpoint(s *Set, np *Npoint) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_set_npoint(s._inner, np._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // IntersectionNpointSet wraps MEOS C function intersection_npoint_set. -func IntersectionNpointSet(np *Npoint, s *Set) *Set { +func IntersectionNpointSet(np *Npoint, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_npoint_set(np._inner, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntersectionSetNpoint wraps MEOS C function intersection_set_npoint. -func IntersectionSetNpoint(s *Set, np *Npoint) *Set { +func IntersectionSetNpoint(s *Set, np *Npoint) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_set_npoint(s._inner, np._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusNpointSet wraps MEOS C function minus_npoint_set. -func MinusNpointSet(np *Npoint, s *Set) *Set { +func MinusNpointSet(np *Npoint, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_npoint_set(np._inner, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusSetNpoint wraps MEOS C function minus_set_npoint. -func MinusSetNpoint(s *Set, np *Npoint) *Set { +func MinusSetNpoint(s *Set, np *Npoint) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_set_npoint(s._inner, np._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // NpointUnionTransfn wraps MEOS C function npoint_union_transfn. -func NpointUnionTransfn(state *Set, np *Npoint) *Set { +func NpointUnionTransfn(state *Set, np *Npoint) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.npoint_union_transfn(state._inner, np._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionNpointSet wraps MEOS C function union_npoint_set. -func UnionNpointSet(np *Npoint, s *Set) *Set { +func UnionNpointSet(np *Npoint, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_npoint_set(np._inner, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionSetNpoint wraps MEOS C function union_set_npoint. -func UnionSetNpoint(s *Set, np *Npoint) *Set { +func UnionSetNpoint(s *Set, np *Npoint) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_set_npoint(s._inner, np._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TnpointIn wraps MEOS C function tnpoint_in. -func TnpointIn(str string) *Temporal { +func TnpointIn(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tnpoint_in(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnpointFromMFJSON wraps MEOS C function tnpoint_from_mfjson. -func TnpointFromMFJSON(mfjson string) *Temporal { +func TnpointFromMFJSON(mfjson string) (_r0 *Temporal, _err error) { _c_mfjson := C.CString(mfjson) defer C.free(unsafe.Pointer(_c_mfjson)) + C.meos_errno_reset() _cret := C.tnpoint_from_mfjson(_c_mfjson) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnpointOut wraps MEOS C function tnpoint_out. -func TnpointOut(temp *Temporal, maxdd int) string { +func TnpointOut(temp *Temporal, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_out(temp._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TnpointinstMake wraps MEOS C function tnpointinst_make. -func TnpointinstMake(np *Npoint, t int64) *TInstant { +func TnpointinstMake(np *Npoint, t int64) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tnpointinst_make(np._inner, C.TimestampTz(t)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TnpointFromBaseTemp wraps MEOS C function tnpoint_from_base_temp. -func TnpointFromBaseTemp(np *Npoint, temp *Temporal) *Temporal { +func TnpointFromBaseTemp(np *Npoint, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_from_base_temp(np._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnpointseqFromBaseTstzset wraps MEOS C function tnpointseq_from_base_tstzset. -func TnpointseqFromBaseTstzset(np *Npoint, s *Set) *TSequence { +func TnpointseqFromBaseTstzset(np *Npoint, s *Set) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tnpointseq_from_base_tstzset(np._inner, s._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TnpointseqFromBaseTstzspan wraps MEOS C function tnpointseq_from_base_tstzspan. -func TnpointseqFromBaseTstzspan(np *Npoint, s *Span, interp Interpolation) *TSequence { +func TnpointseqFromBaseTstzspan(np *Npoint, s *Span, interp Interpolation) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tnpointseq_from_base_tstzspan(np._inner, s._inner, C.interpType(interp)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TnpointseqsetFromBaseTstzspanset wraps MEOS C function tnpointseqset_from_base_tstzspanset. -func TnpointseqsetFromBaseTstzspanset(np *Npoint, ss *SpanSet, interp Interpolation) *TSequenceSet { +func TnpointseqsetFromBaseTstzspanset(np *Npoint, ss *SpanSet, interp Interpolation) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tnpointseqset_from_base_tstzspanset(np._inner, ss._inner, C.interpType(interp)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TgeompointToTnpoint wraps MEOS C function tgeompoint_to_tnpoint. -func TgeompointToTnpoint(temp *Temporal) *Temporal { +func TgeompointToTnpoint(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tgeompoint_to_tnpoint(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnpointToTgeompoint wraps MEOS C function tnpoint_to_tgeompoint. -func TnpointToTgeompoint(temp *Temporal) *Temporal { +func TnpointToTgeompoint(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_to_tgeompoint(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnpointCumulativeLength wraps MEOS C function tnpoint_cumulative_length. -func TnpointCumulativeLength(temp *Temporal) *Temporal { +func TnpointCumulativeLength(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_cumulative_length(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnpointEndValue wraps MEOS C function tnpoint_end_value. -func TnpointEndValue(temp *Temporal) *Npoint { +func TnpointEndValue(temp *Temporal) (_r0 *Npoint, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_end_value(temp._inner) - return &Npoint{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Npoint{_inner: _cret}, nil } // TnpointLength wraps MEOS C function tnpoint_length. -func TnpointLength(temp *Temporal) float64 { +func TnpointLength(temp *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_length(temp._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TnpointPositions wraps MEOS C function tnpoint_positions. -func TnpointPositions(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TnpointPositions(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_positions(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TnpointRoute wraps MEOS C function tnpoint_route. -func TnpointRoute(temp *Temporal) int64 { +func TnpointRoute(temp *Temporal) (_r0 int64, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_route(temp._inner) - return int64(_cret) + if _err = meosError(); _err != nil { + return + } + return int64(_cret), nil } // TnpointRoutes wraps MEOS C function tnpoint_routes. -func TnpointRoutes(temp *Temporal) *Set { +func TnpointRoutes(temp *Temporal) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_routes(temp._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TnpointSpeed wraps MEOS C function tnpoint_speed. -func TnpointSpeed(temp *Temporal) *Temporal { +func TnpointSpeed(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_speed(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnpointStartValue wraps MEOS C function tnpoint_start_value. -func TnpointStartValue(temp *Temporal) *Npoint { +func TnpointStartValue(temp *Temporal) (_r0 *Npoint, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_start_value(temp._inner) - return &Npoint{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Npoint{_inner: _cret}, nil } // TnpointTrajectory wraps MEOS C function tnpoint_trajectory. -func TnpointTrajectory(temp *Temporal) *Geom { +func TnpointTrajectory(temp *Temporal) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_trajectory(temp._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // TnpointValueAtTimestamptz wraps MEOS C function tnpoint_value_at_timestamptz. -func TnpointValueAtTimestamptz(temp *Temporal, t int64, strict bool) (bool, *Npoint) { +func TnpointValueAtTimestamptz(temp *Temporal, t int64, strict bool) (_r0 bool, _r1 *Npoint, _err error) { var _out_value *C.Npoint + C.meos_errno_reset() _cret := C.tnpoint_value_at_timestamptz(temp._inner, C.TimestampTz(t), C.bool(strict), &_out_value) - return bool(_cret), &Npoint{_inner: _out_value} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Npoint{_inner: _out_value}, nil } // TnpointValueN wraps MEOS C function tnpoint_value_n. -func TnpointValueN(temp *Temporal, n int) (bool, *Npoint) { +func TnpointValueN(temp *Temporal, n int) (_r0 bool, _r1 *Npoint, _err error) { var _out_result *C.Npoint + C.meos_errno_reset() _cret := C.tnpoint_value_n(temp._inner, C.int(n), &_out_result) - return bool(_cret), &Npoint{_inner: _out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Npoint{_inner: _out_result}, nil } // TnpointValues wraps MEOS C function tnpoint_values. -func TnpointValues(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TnpointValues(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_values(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TnpointTwcentroid wraps MEOS C function tnpoint_twcentroid. -func TnpointTwcentroid(temp *Temporal) *Geom { +func TnpointTwcentroid(temp *Temporal) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_twcentroid(temp._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // TnpointAtGeom wraps MEOS C function tnpoint_at_geom. -func TnpointAtGeom(temp *Temporal, gs *Geom) *Temporal { +func TnpointAtGeom(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_at_geom(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnpointAtNpoint wraps MEOS C function tnpoint_at_npoint. -func TnpointAtNpoint(temp *Temporal, np *Npoint) *Temporal { +func TnpointAtNpoint(temp *Temporal, np *Npoint) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_at_npoint(temp._inner, np._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnpointAtNpointset wraps MEOS C function tnpoint_at_npointset. -func TnpointAtNpointset(temp *Temporal, s *Set) *Temporal { +func TnpointAtNpointset(temp *Temporal, s *Set) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_at_npointset(temp._inner, s._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnpointAtSTBOX wraps MEOS C function tnpoint_at_stbox. -func TnpointAtSTBOX(temp *Temporal, box *STBox, border_inc bool) *Temporal { +func TnpointAtSTBOX(temp *Temporal, box *STBox, border_inc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_at_stbox(temp._inner, box._inner, C.bool(border_inc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnpointMinusGeom wraps MEOS C function tnpoint_minus_geom. -func TnpointMinusGeom(temp *Temporal, gs *Geom) *Temporal { +func TnpointMinusGeom(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_minus_geom(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnpointMinusNpoint wraps MEOS C function tnpoint_minus_npoint. -func TnpointMinusNpoint(temp *Temporal, np *Npoint) *Temporal { +func TnpointMinusNpoint(temp *Temporal, np *Npoint) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_minus_npoint(temp._inner, np._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnpointMinusNpointset wraps MEOS C function tnpoint_minus_npointset. -func TnpointMinusNpointset(temp *Temporal, s *Set) *Temporal { +func TnpointMinusNpointset(temp *Temporal, s *Set) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_minus_npointset(temp._inner, s._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnpointMinusSTBOX wraps MEOS C function tnpoint_minus_stbox. -func TnpointMinusSTBOX(temp *Temporal, box *STBox, border_inc bool) *Temporal { +func TnpointMinusSTBOX(temp *Temporal, box *STBox, border_inc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_minus_stbox(temp._inner, box._inner, C.bool(border_inc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdistanceTnpointNpoint wraps MEOS C function tdistance_tnpoint_npoint. -func TdistanceTnpointNpoint(temp *Temporal, np *Npoint) *Temporal { +func TdistanceTnpointNpoint(temp *Temporal, np *Npoint) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdistance_tnpoint_npoint(temp._inner, np._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdistanceTnpointGeo wraps MEOS C function tdistance_tnpoint_geo. -func TdistanceTnpointGeo(temp *Temporal, gs *Geom) *Temporal { +func TdistanceTnpointGeo(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdistance_tnpoint_geo(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdistanceTnpointTnpoint wraps MEOS C function tdistance_tnpoint_tnpoint. -func TdistanceTnpointTnpoint(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TdistanceTnpointTnpoint(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdistance_tnpoint_tnpoint(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // NadTnpointGeo wraps MEOS C function nad_tnpoint_geo. -func NadTnpointGeo(temp *Temporal, gs *Geom) float64 { +func NadTnpointGeo(temp *Temporal, gs *Geom) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_tnpoint_geo(temp._inner, gs._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NadTnpointNpoint wraps MEOS C function nad_tnpoint_npoint. -func NadTnpointNpoint(temp *Temporal, np *Npoint) float64 { +func NadTnpointNpoint(temp *Temporal, np *Npoint) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_tnpoint_npoint(temp._inner, np._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NadTnpointSTBOX wraps MEOS C function nad_tnpoint_stbox. -func NadTnpointSTBOX(temp *Temporal, box *STBox) float64 { +func NadTnpointSTBOX(temp *Temporal, box *STBox) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_tnpoint_stbox(temp._inner, box._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NadTnpointTnpoint wraps MEOS C function nad_tnpoint_tnpoint. -func NadTnpointTnpoint(temp1 *Temporal, temp2 *Temporal) float64 { +func NadTnpointTnpoint(temp1 *Temporal, temp2 *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_tnpoint_tnpoint(temp1._inner, temp2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NaiTnpointGeo wraps MEOS C function nai_tnpoint_geo. -func NaiTnpointGeo(temp *Temporal, gs *Geom) *TInstant { +func NaiTnpointGeo(temp *Temporal, gs *Geom) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.nai_tnpoint_geo(temp._inner, gs._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // NaiTnpointNpoint wraps MEOS C function nai_tnpoint_npoint. -func NaiTnpointNpoint(temp *Temporal, np *Npoint) *TInstant { +func NaiTnpointNpoint(temp *Temporal, np *Npoint) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.nai_tnpoint_npoint(temp._inner, np._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // NaiTnpointTnpoint wraps MEOS C function nai_tnpoint_tnpoint. -func NaiTnpointTnpoint(temp1 *Temporal, temp2 *Temporal) *TInstant { +func NaiTnpointTnpoint(temp1 *Temporal, temp2 *Temporal) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.nai_tnpoint_tnpoint(temp1._inner, temp2._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // ShortestlineTnpointGeo wraps MEOS C function shortestline_tnpoint_geo. -func ShortestlineTnpointGeo(temp *Temporal, gs *Geom) *Geom { +func ShortestlineTnpointGeo(temp *Temporal, gs *Geom) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.shortestline_tnpoint_geo(temp._inner, gs._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // ShortestlineTnpointNpoint wraps MEOS C function shortestline_tnpoint_npoint. -func ShortestlineTnpointNpoint(temp *Temporal, np *Npoint) *Geom { +func ShortestlineTnpointNpoint(temp *Temporal, np *Npoint) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.shortestline_tnpoint_npoint(temp._inner, np._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // ShortestlineTnpointTnpoint wraps MEOS C function shortestline_tnpoint_tnpoint. -func ShortestlineTnpointTnpoint(temp1 *Temporal, temp2 *Temporal) *Geom { +func ShortestlineTnpointTnpoint(temp1 *Temporal, temp2 *Temporal) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.shortestline_tnpoint_tnpoint(temp1._inner, temp2._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // TnpointTcentroidTransfn wraps MEOS C function tnpoint_tcentroid_transfn. -func TnpointTcentroidTransfn(state *SkipList, temp *Temporal) *SkipList { +func TnpointTcentroidTransfn(state *SkipList, temp *Temporal) (_r0 *SkipList, _err error) { + C.meos_errno_reset() _cret := C.tnpoint_tcentroid_transfn(state._inner, temp._inner) - return &SkipList{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &SkipList{_inner: _cret}, nil } // AlwaysEqNpointTnpoint wraps MEOS C function always_eq_npoint_tnpoint. -func AlwaysEqNpointTnpoint(np *Npoint, temp *Temporal) int { +func AlwaysEqNpointTnpoint(np *Npoint, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_npoint_tnpoint(np._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTnpointNpoint wraps MEOS C function always_eq_tnpoint_npoint. -func AlwaysEqTnpointNpoint(temp *Temporal, np *Npoint) int { +func AlwaysEqTnpointNpoint(temp *Temporal, np *Npoint) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_tnpoint_npoint(temp._inner, np._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTnpointTnpoint wraps MEOS C function always_eq_tnpoint_tnpoint. -func AlwaysEqTnpointTnpoint(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysEqTnpointTnpoint(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_tnpoint_tnpoint(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeNpointTnpoint wraps MEOS C function always_ne_npoint_tnpoint. -func AlwaysNeNpointTnpoint(np *Npoint, temp *Temporal) int { +func AlwaysNeNpointTnpoint(np *Npoint, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_npoint_tnpoint(np._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTnpointNpoint wraps MEOS C function always_ne_tnpoint_npoint. -func AlwaysNeTnpointNpoint(temp *Temporal, np *Npoint) int { +func AlwaysNeTnpointNpoint(temp *Temporal, np *Npoint) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_tnpoint_npoint(temp._inner, np._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTnpointTnpoint wraps MEOS C function always_ne_tnpoint_tnpoint. -func AlwaysNeTnpointTnpoint(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysNeTnpointTnpoint(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_tnpoint_tnpoint(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqNpointTnpoint wraps MEOS C function ever_eq_npoint_tnpoint. -func EverEqNpointTnpoint(np *Npoint, temp *Temporal) int { +func EverEqNpointTnpoint(np *Npoint, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_npoint_tnpoint(np._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTnpointNpoint wraps MEOS C function ever_eq_tnpoint_npoint. -func EverEqTnpointNpoint(temp *Temporal, np *Npoint) int { +func EverEqTnpointNpoint(temp *Temporal, np *Npoint) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_tnpoint_npoint(temp._inner, np._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTnpointTnpoint wraps MEOS C function ever_eq_tnpoint_tnpoint. -func EverEqTnpointTnpoint(temp1 *Temporal, temp2 *Temporal) int { +func EverEqTnpointTnpoint(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_tnpoint_tnpoint(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeNpointTnpoint wraps MEOS C function ever_ne_npoint_tnpoint. -func EverNeNpointTnpoint(np *Npoint, temp *Temporal) int { +func EverNeNpointTnpoint(np *Npoint, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_npoint_tnpoint(np._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTnpointNpoint wraps MEOS C function ever_ne_tnpoint_npoint. -func EverNeTnpointNpoint(temp *Temporal, np *Npoint) int { +func EverNeTnpointNpoint(temp *Temporal, np *Npoint) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_tnpoint_npoint(temp._inner, np._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTnpointTnpoint wraps MEOS C function ever_ne_tnpoint_tnpoint. -func EverNeTnpointTnpoint(temp1 *Temporal, temp2 *Temporal) int { +func EverNeTnpointTnpoint(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_tnpoint_tnpoint(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TeqTnpointNpoint wraps MEOS C function teq_tnpoint_npoint. -func TeqTnpointNpoint(temp *Temporal, np *Npoint) *Temporal { +func TeqTnpointNpoint(temp *Temporal, np *Npoint) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_tnpoint_npoint(temp._inner, np._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneTnpointNpoint wraps MEOS C function tne_tnpoint_npoint. -func TneTnpointNpoint(temp *Temporal, np *Npoint) *Temporal { +func TneTnpointNpoint(temp *Temporal, np *Npoint) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_tnpoint_npoint(temp._inner, np._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } diff --git a/functions/meos_meos_pointcloud.go b/functions/meos_meos_pointcloud.go index fdcabe6..0f97570 100644 --- a/functions/meos_meos_pointcloud.go +++ b/functions/meos_meos_pointcloud.go @@ -86,1363 +86,2126 @@ import ( var _ = unsafe.Pointer(nil) // PcpointHexIn wraps MEOS C function pcpoint_hex_in. -func PcpointHexIn(str string) *Pcpoint { +func PcpointHexIn(str string) (_r0 *Pcpoint, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.pcpoint_hex_in(_c_str) - return &Pcpoint{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pcpoint{_inner: _cret}, nil } // PcpointHexOut wraps MEOS C function pcpoint_hex_out. -func PcpointHexOut(pt *Pcpoint, maxdd int) string { +func PcpointHexOut(pt *Pcpoint, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.pcpoint_hex_out(pt._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // PcpointFromHexwkb wraps MEOS C function pcpoint_from_hexwkb. -func PcpointFromHexwkb(hexwkb string) *Pcpoint { +func PcpointFromHexwkb(hexwkb string) (_r0 *Pcpoint, _err error) { _c_hexwkb := C.CString(hexwkb) defer C.free(unsafe.Pointer(_c_hexwkb)) + C.meos_errno_reset() _cret := C.pcpoint_from_hexwkb(_c_hexwkb) - return &Pcpoint{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pcpoint{_inner: _cret}, nil } // PcpointAsHexwkb wraps MEOS C function pcpoint_as_hexwkb. -func PcpointAsHexwkb(pt *Pcpoint) string { +func PcpointAsHexwkb(pt *Pcpoint) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.pcpoint_as_hexwkb(pt._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // PcpointCopy wraps MEOS C function pcpoint_copy. -func PcpointCopy(pt *Pcpoint) *Pcpoint { +func PcpointCopy(pt *Pcpoint) (_r0 *Pcpoint, _err error) { + C.meos_errno_reset() _cret := C.pcpoint_copy(pt._inner) - return &Pcpoint{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pcpoint{_inner: _cret}, nil } // PcpointGetPcid wraps MEOS C function pcpoint_get_pcid. -func PcpointGetPcid(pt *Pcpoint) uint32 { +func PcpointGetPcid(pt *Pcpoint) (_r0 uint32, _err error) { + C.meos_errno_reset() _cret := C.pcpoint_get_pcid(pt._inner) - return uint32(_cret) + if _err = meosError(); _err != nil { + return + } + return uint32(_cret), nil } // PcpointHash wraps MEOS C function pcpoint_hash. -func PcpointHash(pt *Pcpoint) uint32 { +func PcpointHash(pt *Pcpoint) (_r0 uint32, _err error) { + C.meos_errno_reset() _cret := C.pcpoint_hash(pt._inner) - return uint32(_cret) + if _err = meosError(); _err != nil { + return + } + return uint32(_cret), nil } // PcpointHashExtended wraps MEOS C function pcpoint_hash_extended. -func PcpointHashExtended(pt *Pcpoint, seed uint64) uint64 { +func PcpointHashExtended(pt *Pcpoint, seed uint64) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.pcpoint_hash_extended(pt._inner, C.uint64_t(seed)) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // PcpointGetX wraps MEOS C function pcpoint_get_x. -func PcpointGetX(pt *Pcpoint, schema *PCSchema, out unsafe.Pointer) bool { +func PcpointGetX(pt *Pcpoint, schema *PCSchema, out unsafe.Pointer) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pcpoint_get_x(pt._inner, schema._inner, (*C.double)(unsafe.Pointer(out))) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PcpointGetY wraps MEOS C function pcpoint_get_y. -func PcpointGetY(pt *Pcpoint, schema *PCSchema, out unsafe.Pointer) bool { +func PcpointGetY(pt *Pcpoint, schema *PCSchema, out unsafe.Pointer) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pcpoint_get_y(pt._inner, schema._inner, (*C.double)(unsafe.Pointer(out))) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PcpointGetZ wraps MEOS C function pcpoint_get_z. -func PcpointGetZ(pt *Pcpoint, schema *PCSchema, out unsafe.Pointer) bool { +func PcpointGetZ(pt *Pcpoint, schema *PCSchema, out unsafe.Pointer) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pcpoint_get_z(pt._inner, schema._inner, (*C.double)(unsafe.Pointer(out))) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PcpointGetDim wraps MEOS C function pcpoint_get_dim. -func PcpointGetDim(pt *Pcpoint, schema *PCSchema, name string, out unsafe.Pointer) bool { +func PcpointGetDim(pt *Pcpoint, schema *PCSchema, name string, out unsafe.Pointer) (_r0 bool, _err error) { _c_name := C.CString(name) defer C.free(unsafe.Pointer(_c_name)) + C.meos_errno_reset() _cret := C.pcpoint_get_dim(pt._inner, schema._inner, _c_name, (*C.double)(unsafe.Pointer(out))) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PcpointToTpcbox wraps MEOS C function pcpoint_to_tpcbox. -func PcpointToTpcbox(pt *Pcpoint, schema *PCSchema) *TPCBox { +func PcpointToTpcbox(pt *Pcpoint, schema *PCSchema) (_r0 *TPCBox, _err error) { + C.meos_errno_reset() _cret := C.pcpoint_to_tpcbox(pt._inner, schema._inner) - return &TPCBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TPCBox{_inner: _cret}, nil } // MeosPcSchema wraps MEOS C function meos_pc_schema. -func MeosPcSchema(pcid uint32) *PCSchema { +func MeosPcSchema(pcid uint32) (_r0 *PCSchema, _err error) { + C.meos_errno_reset() _cret := C.meos_pc_schema(C.uint32_t(pcid)) - return &PCSchema{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &PCSchema{_inner: _cret}, nil } // MeosPcSchemaRegister wraps MEOS C function meos_pc_schema_register. -func MeosPcSchemaRegister(pcid uint32, schema *PCSchema) { +func MeosPcSchemaRegister(pcid uint32, schema *PCSchema) (_err error) { + C.meos_errno_reset() C.meos_pc_schema_register(C.uint32_t(pcid), schema._inner) + if _err = meosError(); _err != nil { + return + } + return nil } // MeosPcSchemaRegisterXml wraps MEOS C function meos_pc_schema_register_xml. -func MeosPcSchemaRegisterXml(pcid uint32, schema *PCSchema, xml_text string) { +func MeosPcSchemaRegisterXml(pcid uint32, schema *PCSchema, xml_text string) (_err error) { _c_xml_text := C.CString(xml_text) defer C.free(unsafe.Pointer(_c_xml_text)) + C.meos_errno_reset() C.meos_pc_schema_register_xml(C.uint32_t(pcid), schema._inner, _c_xml_text) + if _err = meosError(); _err != nil { + return + } + return nil } // MeosPcSchemaXml wraps MEOS C function meos_pc_schema_xml. -func MeosPcSchemaXml(pcid uint32) string { +func MeosPcSchemaXml(pcid uint32) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.meos_pc_schema_xml(C.uint32_t(pcid)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // MeosPcSchemaClear wraps MEOS C function meos_pc_schema_clear. -func MeosPcSchemaClear() { +func MeosPcSchemaClear() (_err error) { + C.meos_errno_reset() C.meos_pc_schema_clear() + if _err = meosError(); _err != nil { + return + } + return nil } // PcpointCmp wraps MEOS C function pcpoint_cmp. -func PcpointCmp(pt1 *Pcpoint, pt2 *Pcpoint) int { +func PcpointCmp(pt1 *Pcpoint, pt2 *Pcpoint) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.pcpoint_cmp(pt1._inner, pt2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // PcpointEq wraps MEOS C function pcpoint_eq. -func PcpointEq(pt1 *Pcpoint, pt2 *Pcpoint) bool { +func PcpointEq(pt1 *Pcpoint, pt2 *Pcpoint) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pcpoint_eq(pt1._inner, pt2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PcpointNe wraps MEOS C function pcpoint_ne. -func PcpointNe(pt1 *Pcpoint, pt2 *Pcpoint) bool { +func PcpointNe(pt1 *Pcpoint, pt2 *Pcpoint) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pcpoint_ne(pt1._inner, pt2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PcpointLt wraps MEOS C function pcpoint_lt. -func PcpointLt(pt1 *Pcpoint, pt2 *Pcpoint) bool { +func PcpointLt(pt1 *Pcpoint, pt2 *Pcpoint) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pcpoint_lt(pt1._inner, pt2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PcpointLe wraps MEOS C function pcpoint_le. -func PcpointLe(pt1 *Pcpoint, pt2 *Pcpoint) bool { +func PcpointLe(pt1 *Pcpoint, pt2 *Pcpoint) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pcpoint_le(pt1._inner, pt2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PcpointGt wraps MEOS C function pcpoint_gt. -func PcpointGt(pt1 *Pcpoint, pt2 *Pcpoint) bool { +func PcpointGt(pt1 *Pcpoint, pt2 *Pcpoint) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pcpoint_gt(pt1._inner, pt2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PcpointGe wraps MEOS C function pcpoint_ge. -func PcpointGe(pt1 *Pcpoint, pt2 *Pcpoint) bool { +func PcpointGe(pt1 *Pcpoint, pt2 *Pcpoint) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pcpoint_ge(pt1._inner, pt2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PcpatchHexIn wraps MEOS C function pcpatch_hex_in. -func PcpatchHexIn(str string) *Pcpatch { +func PcpatchHexIn(str string) (_r0 *Pcpatch, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.pcpatch_hex_in(_c_str) - return &Pcpatch{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pcpatch{_inner: _cret}, nil } // PcpatchHexOut wraps MEOS C function pcpatch_hex_out. -func PcpatchHexOut(pa *Pcpatch, maxdd int) string { +func PcpatchHexOut(pa *Pcpatch, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.pcpatch_hex_out(pa._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // PcpatchFromHexwkb wraps MEOS C function pcpatch_from_hexwkb. -func PcpatchFromHexwkb(hexwkb string) *Pcpatch { +func PcpatchFromHexwkb(hexwkb string) (_r0 *Pcpatch, _err error) { _c_hexwkb := C.CString(hexwkb) defer C.free(unsafe.Pointer(_c_hexwkb)) + C.meos_errno_reset() _cret := C.pcpatch_from_hexwkb(_c_hexwkb) - return &Pcpatch{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pcpatch{_inner: _cret}, nil } // PcpatchAsHexwkb wraps MEOS C function pcpatch_as_hexwkb. -func PcpatchAsHexwkb(pa *Pcpatch) string { +func PcpatchAsHexwkb(pa *Pcpatch) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.pcpatch_as_hexwkb(pa._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // PcpatchCopy wraps MEOS C function pcpatch_copy. -func PcpatchCopy(pa *Pcpatch) *Pcpatch { +func PcpatchCopy(pa *Pcpatch) (_r0 *Pcpatch, _err error) { + C.meos_errno_reset() _cret := C.pcpatch_copy(pa._inner) - return &Pcpatch{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pcpatch{_inner: _cret}, nil } // PcpatchGetPcid wraps MEOS C function pcpatch_get_pcid. -func PcpatchGetPcid(pa *Pcpatch) uint32 { +func PcpatchGetPcid(pa *Pcpatch) (_r0 uint32, _err error) { + C.meos_errno_reset() _cret := C.pcpatch_get_pcid(pa._inner) - return uint32(_cret) + if _err = meosError(); _err != nil { + return + } + return uint32(_cret), nil } // PcpatchNpoints wraps MEOS C function pcpatch_npoints. -func PcpatchNpoints(pa *Pcpatch) uint32 { +func PcpatchNpoints(pa *Pcpatch) (_r0 uint32, _err error) { + C.meos_errno_reset() _cret := C.pcpatch_npoints(pa._inner) - return uint32(_cret) + if _err = meosError(); _err != nil { + return + } + return uint32(_cret), nil } // PcpatchHash wraps MEOS C function pcpatch_hash. -func PcpatchHash(pa *Pcpatch) uint32 { +func PcpatchHash(pa *Pcpatch) (_r0 uint32, _err error) { + C.meos_errno_reset() _cret := C.pcpatch_hash(pa._inner) - return uint32(_cret) + if _err = meosError(); _err != nil { + return + } + return uint32(_cret), nil } // PcpatchHashExtended wraps MEOS C function pcpatch_hash_extended. -func PcpatchHashExtended(pa *Pcpatch, seed uint64) uint64 { +func PcpatchHashExtended(pa *Pcpatch, seed uint64) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.pcpatch_hash_extended(pa._inner, C.uint64_t(seed)) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // PcpatchCmp wraps MEOS C function pcpatch_cmp. -func PcpatchCmp(pa1 *Pcpatch, pa2 *Pcpatch) int { +func PcpatchCmp(pa1 *Pcpatch, pa2 *Pcpatch) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.pcpatch_cmp(pa1._inner, pa2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // PcpatchEq wraps MEOS C function pcpatch_eq. -func PcpatchEq(pa1 *Pcpatch, pa2 *Pcpatch) bool { +func PcpatchEq(pa1 *Pcpatch, pa2 *Pcpatch) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pcpatch_eq(pa1._inner, pa2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PcpatchNe wraps MEOS C function pcpatch_ne. -func PcpatchNe(pa1 *Pcpatch, pa2 *Pcpatch) bool { +func PcpatchNe(pa1 *Pcpatch, pa2 *Pcpatch) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pcpatch_ne(pa1._inner, pa2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PcpatchLt wraps MEOS C function pcpatch_lt. -func PcpatchLt(pa1 *Pcpatch, pa2 *Pcpatch) bool { +func PcpatchLt(pa1 *Pcpatch, pa2 *Pcpatch) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pcpatch_lt(pa1._inner, pa2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PcpatchLe wraps MEOS C function pcpatch_le. -func PcpatchLe(pa1 *Pcpatch, pa2 *Pcpatch) bool { +func PcpatchLe(pa1 *Pcpatch, pa2 *Pcpatch) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pcpatch_le(pa1._inner, pa2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PcpatchGt wraps MEOS C function pcpatch_gt. -func PcpatchGt(pa1 *Pcpatch, pa2 *Pcpatch) bool { +func PcpatchGt(pa1 *Pcpatch, pa2 *Pcpatch) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pcpatch_gt(pa1._inner, pa2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PcpatchGe wraps MEOS C function pcpatch_ge. -func PcpatchGe(pa1 *Pcpatch, pa2 *Pcpatch) bool { +func PcpatchGe(pa1 *Pcpatch, pa2 *Pcpatch) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pcpatch_ge(pa1._inner, pa2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PcpointsetIn wraps MEOS C function pcpointset_in. -func PcpointsetIn(str string) *Set { +func PcpointsetIn(str string) (_r0 *Set, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.pcpointset_in(_c_str) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // PcpointsetOut wraps MEOS C function pcpointset_out. -func PcpointsetOut(s *Set, maxdd int) string { +func PcpointsetOut(s *Set, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.pcpointset_out(s._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // PcpointsetMake wraps MEOS C function pcpointset_make. -func PcpointsetMake(values unsafe.Pointer, count int) *Set { +func PcpointsetMake(values unsafe.Pointer, count int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.pcpointset_make((**C.Pcpoint)(unsafe.Pointer(values)), C.int(count)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // PcpointToSet wraps MEOS C function pcpoint_to_set. -func PcpointToSet(pt *Pcpoint) *Set { +func PcpointToSet(pt *Pcpoint) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.pcpoint_to_set(pt._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // PcpointsetStartValue wraps MEOS C function pcpointset_start_value. -func PcpointsetStartValue(s *Set) *Pcpoint { +func PcpointsetStartValue(s *Set) (_r0 *Pcpoint, _err error) { + C.meos_errno_reset() _cret := C.pcpointset_start_value(s._inner) - return &Pcpoint{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pcpoint{_inner: _cret}, nil } // PcpointsetEndValue wraps MEOS C function pcpointset_end_value. -func PcpointsetEndValue(s *Set) *Pcpoint { +func PcpointsetEndValue(s *Set) (_r0 *Pcpoint, _err error) { + C.meos_errno_reset() _cret := C.pcpointset_end_value(s._inner) - return &Pcpoint{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pcpoint{_inner: _cret}, nil } // PcpointsetValueN wraps MEOS C function pcpointset_value_n. -func PcpointsetValueN(s *Set, n int) (bool, *Pcpoint) { +func PcpointsetValueN(s *Set, n int) (_r0 bool, _r1 *Pcpoint, _err error) { var _out_result *C.Pcpoint + C.meos_errno_reset() _cret := C.pcpointset_value_n(s._inner, C.int(n), &_out_result) - return bool(_cret), &Pcpoint{_inner: _out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Pcpoint{_inner: _out_result}, nil } // PcpointsetValues wraps MEOS C function pcpointset_values. -func PcpointsetValues(s *Set, count unsafe.Pointer) unsafe.Pointer { +func PcpointsetValues(s *Set, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.pcpointset_values(s._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // ContainsSetPcpoint wraps MEOS C function contains_set_pcpoint. -func ContainsSetPcpoint(s *Set, pt *Pcpoint) bool { +func ContainsSetPcpoint(s *Set, pt *Pcpoint) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_set_pcpoint(s._inner, pt._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedPcpointSet wraps MEOS C function contained_pcpoint_set. -func ContainedPcpointSet(pt *Pcpoint, s *Set) bool { +func ContainedPcpointSet(pt *Pcpoint, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_pcpoint_set(pt._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // IntersectionPcpointSet wraps MEOS C function intersection_pcpoint_set. -func IntersectionPcpointSet(pt *Pcpoint, s *Set) *Set { +func IntersectionPcpointSet(pt *Pcpoint, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_pcpoint_set(pt._inner, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntersectionSetPcpoint wraps MEOS C function intersection_set_pcpoint. -func IntersectionSetPcpoint(s *Set, pt *Pcpoint) *Set { +func IntersectionSetPcpoint(s *Set, pt *Pcpoint) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_set_pcpoint(s._inner, pt._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusPcpointSet wraps MEOS C function minus_pcpoint_set. -func MinusPcpointSet(pt *Pcpoint, s *Set) *Set { +func MinusPcpointSet(pt *Pcpoint, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_pcpoint_set(pt._inner, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusSetPcpoint wraps MEOS C function minus_set_pcpoint. -func MinusSetPcpoint(s *Set, pt *Pcpoint) *Set { +func MinusSetPcpoint(s *Set, pt *Pcpoint) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_set_pcpoint(s._inner, pt._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionPcpointSet wraps MEOS C function union_pcpoint_set. -func UnionPcpointSet(pt *Pcpoint, s *Set) *Set { +func UnionPcpointSet(pt *Pcpoint, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_pcpoint_set(pt._inner, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionSetPcpoint wraps MEOS C function union_set_pcpoint. -func UnionSetPcpoint(s *Set, pt *Pcpoint) *Set { +func UnionSetPcpoint(s *Set, pt *Pcpoint) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_set_pcpoint(s._inner, pt._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // PcpointUnionTransfn wraps MEOS C function pcpoint_union_transfn. -func PcpointUnionTransfn(state *Set, pt *Pcpoint) *Set { +func PcpointUnionTransfn(state *Set, pt *Pcpoint) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.pcpoint_union_transfn(state._inner, pt._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // PcpatchsetIn wraps MEOS C function pcpatchset_in. -func PcpatchsetIn(str string) *Set { +func PcpatchsetIn(str string) (_r0 *Set, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.pcpatchset_in(_c_str) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // PcpatchsetOut wraps MEOS C function pcpatchset_out. -func PcpatchsetOut(s *Set, maxdd int) string { +func PcpatchsetOut(s *Set, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.pcpatchset_out(s._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // PcpatchsetMake wraps MEOS C function pcpatchset_make. -func PcpatchsetMake(values unsafe.Pointer, count int) *Set { +func PcpatchsetMake(values unsafe.Pointer, count int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.pcpatchset_make((**C.Pcpatch)(unsafe.Pointer(values)), C.int(count)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // PcpatchToSet wraps MEOS C function pcpatch_to_set. -func PcpatchToSet(pa *Pcpatch) *Set { +func PcpatchToSet(pa *Pcpatch) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.pcpatch_to_set(pa._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // PcpatchsetStartValue wraps MEOS C function pcpatchset_start_value. -func PcpatchsetStartValue(s *Set) *Pcpatch { +func PcpatchsetStartValue(s *Set) (_r0 *Pcpatch, _err error) { + C.meos_errno_reset() _cret := C.pcpatchset_start_value(s._inner) - return &Pcpatch{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pcpatch{_inner: _cret}, nil } // PcpatchsetEndValue wraps MEOS C function pcpatchset_end_value. -func PcpatchsetEndValue(s *Set) *Pcpatch { +func PcpatchsetEndValue(s *Set) (_r0 *Pcpatch, _err error) { + C.meos_errno_reset() _cret := C.pcpatchset_end_value(s._inner) - return &Pcpatch{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pcpatch{_inner: _cret}, nil } // PcpatchsetValueN wraps MEOS C function pcpatchset_value_n. -func PcpatchsetValueN(s *Set, n int) (bool, *Pcpatch) { +func PcpatchsetValueN(s *Set, n int) (_r0 bool, _r1 *Pcpatch, _err error) { var _out_result *C.Pcpatch + C.meos_errno_reset() _cret := C.pcpatchset_value_n(s._inner, C.int(n), &_out_result) - return bool(_cret), &Pcpatch{_inner: _out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Pcpatch{_inner: _out_result}, nil } // PcpatchsetValues wraps MEOS C function pcpatchset_values. -func PcpatchsetValues(s *Set, count unsafe.Pointer) unsafe.Pointer { +func PcpatchsetValues(s *Set, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.pcpatchset_values(s._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // ContainsSetPcpatch wraps MEOS C function contains_set_pcpatch. -func ContainsSetPcpatch(s *Set, pa *Pcpatch) bool { +func ContainsSetPcpatch(s *Set, pa *Pcpatch) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_set_pcpatch(s._inner, pa._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedPcpatchSet wraps MEOS C function contained_pcpatch_set. -func ContainedPcpatchSet(pa *Pcpatch, s *Set) bool { +func ContainedPcpatchSet(pa *Pcpatch, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_pcpatch_set(pa._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // IntersectionPcpatchSet wraps MEOS C function intersection_pcpatch_set. -func IntersectionPcpatchSet(pa *Pcpatch, s *Set) *Set { +func IntersectionPcpatchSet(pa *Pcpatch, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_pcpatch_set(pa._inner, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntersectionSetPcpatch wraps MEOS C function intersection_set_pcpatch. -func IntersectionSetPcpatch(s *Set, pa *Pcpatch) *Set { +func IntersectionSetPcpatch(s *Set, pa *Pcpatch) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_set_pcpatch(s._inner, pa._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusPcpatchSet wraps MEOS C function minus_pcpatch_set. -func MinusPcpatchSet(pa *Pcpatch, s *Set) *Set { +func MinusPcpatchSet(pa *Pcpatch, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_pcpatch_set(pa._inner, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusSetPcpatch wraps MEOS C function minus_set_pcpatch. -func MinusSetPcpatch(s *Set, pa *Pcpatch) *Set { +func MinusSetPcpatch(s *Set, pa *Pcpatch) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_set_pcpatch(s._inner, pa._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionPcpatchSet wraps MEOS C function union_pcpatch_set. -func UnionPcpatchSet(pa *Pcpatch, s *Set) *Set { +func UnionPcpatchSet(pa *Pcpatch, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_pcpatch_set(pa._inner, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionSetPcpatch wraps MEOS C function union_set_pcpatch. -func UnionSetPcpatch(s *Set, pa *Pcpatch) *Set { +func UnionSetPcpatch(s *Set, pa *Pcpatch) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_set_pcpatch(s._inner, pa._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // PcpatchUnionTransfn wraps MEOS C function pcpatch_union_transfn. -func PcpatchUnionTransfn(state *Set, pa *Pcpatch) *Set { +func PcpatchUnionTransfn(state *Set, pa *Pcpatch) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.pcpatch_union_transfn(state._inner, pa._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TpcboxIn wraps MEOS C function tpcbox_in. -func TpcboxIn(str string) *TPCBox { +func TpcboxIn(str string) (_r0 *TPCBox, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tpcbox_in(_c_str) - return &TPCBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TPCBox{_inner: _cret}, nil } // TpcboxOut wraps MEOS C function tpcbox_out. -func TpcboxOut(box *TPCBox, maxdd int) string { +func TpcboxOut(box *TPCBox, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.tpcbox_out(box._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TpcboxMake wraps MEOS C function tpcbox_make. -func TpcboxMake(hasx bool, hasz bool, hast bool, geodetic bool, srid int32, pcid uint32, xmin float64, xmax float64, ymin float64, ymax float64, zmin float64, zmax float64, period *Span) *TPCBox { +func TpcboxMake(hasx bool, hasz bool, hast bool, geodetic bool, srid int32, pcid uint32, xmin float64, xmax float64, ymin float64, ymax float64, zmin float64, zmax float64, period *Span) (_r0 *TPCBox, _err error) { + C.meos_errno_reset() _cret := C.tpcbox_make(C.bool(hasx), C.bool(hasz), C.bool(hast), C.bool(geodetic), C.int32_t(srid), C.uint32_t(pcid), C.double(xmin), C.double(xmax), C.double(ymin), C.double(ymax), C.double(zmin), C.double(zmax), period._inner) - return &TPCBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TPCBox{_inner: _cret}, nil } // TpcboxCopy wraps MEOS C function tpcbox_copy. -func TpcboxCopy(box *TPCBox) *TPCBox { +func TpcboxCopy(box *TPCBox) (_r0 *TPCBox, _err error) { + C.meos_errno_reset() _cret := C.tpcbox_copy(box._inner) - return &TPCBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TPCBox{_inner: _cret}, nil } // PcpatchToTpcbox wraps MEOS C function pcpatch_to_tpcbox. -func PcpatchToTpcbox(pa *Pcpatch, srid int32) *TPCBox { +func PcpatchToTpcbox(pa *Pcpatch, srid int32) (_r0 *TPCBox, _err error) { + C.meos_errno_reset() _cret := C.pcpatch_to_tpcbox(pa._inner, C.int32_t(srid)) - return &TPCBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TPCBox{_inner: _cret}, nil } // TpcboxHasx wraps MEOS C function tpcbox_hasx. -func TpcboxHasx(box *TPCBox) bool { +func TpcboxHasx(box *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tpcbox_hasx(box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TpcboxHasz wraps MEOS C function tpcbox_hasz. -func TpcboxHasz(box *TPCBox) bool { +func TpcboxHasz(box *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tpcbox_hasz(box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TpcboxHast wraps MEOS C function tpcbox_hast. -func TpcboxHast(box *TPCBox) bool { +func TpcboxHast(box *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tpcbox_hast(box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TpcboxGeodetic wraps MEOS C function tpcbox_geodetic. -func TpcboxGeodetic(box *TPCBox) bool { +func TpcboxGeodetic(box *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tpcbox_geodetic(box._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TpcboxXmin wraps MEOS C function tpcbox_xmin. -func TpcboxXmin(box *TPCBox) (bool, float64) { +func TpcboxXmin(box *TPCBox) (_r0 bool, _r1 float64, _err error) { var _out_result C.double + C.meos_errno_reset() _cret := C.tpcbox_xmin(box._inner, &_out_result) - return bool(_cret), float64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), float64(_out_result), nil } // TpcboxXmax wraps MEOS C function tpcbox_xmax. -func TpcboxXmax(box *TPCBox) (bool, float64) { +func TpcboxXmax(box *TPCBox) (_r0 bool, _r1 float64, _err error) { var _out_result C.double + C.meos_errno_reset() _cret := C.tpcbox_xmax(box._inner, &_out_result) - return bool(_cret), float64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), float64(_out_result), nil } // TpcboxYmin wraps MEOS C function tpcbox_ymin. -func TpcboxYmin(box *TPCBox) (bool, float64) { +func TpcboxYmin(box *TPCBox) (_r0 bool, _r1 float64, _err error) { var _out_result C.double + C.meos_errno_reset() _cret := C.tpcbox_ymin(box._inner, &_out_result) - return bool(_cret), float64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), float64(_out_result), nil } // TpcboxYmax wraps MEOS C function tpcbox_ymax. -func TpcboxYmax(box *TPCBox) (bool, float64) { +func TpcboxYmax(box *TPCBox) (_r0 bool, _r1 float64, _err error) { var _out_result C.double + C.meos_errno_reset() _cret := C.tpcbox_ymax(box._inner, &_out_result) - return bool(_cret), float64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), float64(_out_result), nil } // TpcboxZmin wraps MEOS C function tpcbox_zmin. -func TpcboxZmin(box *TPCBox) (bool, float64) { +func TpcboxZmin(box *TPCBox) (_r0 bool, _r1 float64, _err error) { var _out_result C.double + C.meos_errno_reset() _cret := C.tpcbox_zmin(box._inner, &_out_result) - return bool(_cret), float64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), float64(_out_result), nil } // TpcboxZmax wraps MEOS C function tpcbox_zmax. -func TpcboxZmax(box *TPCBox) (bool, float64) { +func TpcboxZmax(box *TPCBox) (_r0 bool, _r1 float64, _err error) { var _out_result C.double + C.meos_errno_reset() _cret := C.tpcbox_zmax(box._inner, &_out_result) - return bool(_cret), float64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), float64(_out_result), nil } // TpcboxTmin wraps MEOS C function tpcbox_tmin. -func TpcboxTmin(box *TPCBox) (bool, int64) { +func TpcboxTmin(box *TPCBox) (_r0 bool, _r1 int64, _err error) { var _out_result C.TimestampTz + C.meos_errno_reset() _cret := C.tpcbox_tmin(box._inner, &_out_result) - return bool(_cret), int64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), int64(_out_result), nil } // TpcboxTminInc wraps MEOS C function tpcbox_tmin_inc. -func TpcboxTminInc(box *TPCBox) (bool, bool) { +func TpcboxTminInc(box *TPCBox) (_r0 bool, _r1 bool, _err error) { var _out_result C.bool + C.meos_errno_reset() _cret := C.tpcbox_tmin_inc(box._inner, &_out_result) - return bool(_cret), bool(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), bool(_out_result), nil } // TpcboxTmax wraps MEOS C function tpcbox_tmax. -func TpcboxTmax(box *TPCBox) (bool, int64) { +func TpcboxTmax(box *TPCBox) (_r0 bool, _r1 int64, _err error) { var _out_result C.TimestampTz + C.meos_errno_reset() _cret := C.tpcbox_tmax(box._inner, &_out_result) - return bool(_cret), int64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), int64(_out_result), nil } // TpcboxTmaxInc wraps MEOS C function tpcbox_tmax_inc. -func TpcboxTmaxInc(box *TPCBox) (bool, bool) { +func TpcboxTmaxInc(box *TPCBox) (_r0 bool, _r1 bool, _err error) { var _out_result C.bool + C.meos_errno_reset() _cret := C.tpcbox_tmax_inc(box._inner, &_out_result) - return bool(_cret), bool(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), bool(_out_result), nil } // TpcboxSRID wraps MEOS C function tpcbox_srid. -func TpcboxSRID(box *TPCBox) int32 { +func TpcboxSRID(box *TPCBox) (_r0 int32, _err error) { + C.meos_errno_reset() _cret := C.tpcbox_srid(box._inner) - return int32(_cret) + if _err = meosError(); _err != nil { + return + } + return int32(_cret), nil } // TpcboxPcid wraps MEOS C function tpcbox_pcid. -func TpcboxPcid(box *TPCBox) uint32 { +func TpcboxPcid(box *TPCBox) (_r0 uint32, _err error) { + C.meos_errno_reset() _cret := C.tpcbox_pcid(box._inner) - return uint32(_cret) + if _err = meosError(); _err != nil { + return + } + return uint32(_cret), nil } // TpcboxToSTBOX wraps MEOS C function tpcbox_to_stbox. -func TpcboxToSTBOX(box *TPCBox) *STBox { +func TpcboxToSTBOX(box *TPCBox) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.tpcbox_to_stbox(box._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // TpcboxRound wraps MEOS C function tpcbox_round. -func TpcboxRound(box *TPCBox, maxdd int) *TPCBox { +func TpcboxRound(box *TPCBox, maxdd int) (_r0 *TPCBox, _err error) { + C.meos_errno_reset() _cret := C.tpcbox_round(box._inner, C.int(maxdd)) - return &TPCBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TPCBox{_inner: _cret}, nil } // TpcboxSetSRID wraps MEOS C function tpcbox_set_srid. -func TpcboxSetSRID(box *TPCBox, srid int32) *TPCBox { +func TpcboxSetSRID(box *TPCBox, srid int32) (_r0 *TPCBox, _err error) { + C.meos_errno_reset() _cret := C.tpcbox_set_srid(box._inner, C.int32_t(srid)) - return &TPCBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TPCBox{_inner: _cret}, nil } // UnionTpcboxTpcbox wraps MEOS C function union_tpcbox_tpcbox. -func UnionTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox, strict bool) *TPCBox { +func UnionTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox, strict bool) (_r0 *TPCBox, _err error) { + C.meos_errno_reset() _cret := C.gunion_tpcbox_tpcbox(box1._inner, box2._inner, C.bool(strict)) - return &TPCBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TPCBox{_inner: _cret}, nil } // InterTpcboxTpcbox wraps MEOS C function inter_tpcbox_tpcbox. -func InterTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (bool, *TPCBox) { +func InterTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _r1 *TPCBox, _err error) { var _out_result C.TPCBox + C.meos_errno_reset() _cret := C.inter_tpcbox_tpcbox(box1._inner, box2._inner, &_out_result) - return bool(_cret), &TPCBox{_inner: &_out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &TPCBox{_inner: &_out_result}, nil } // IntersectionTpcboxTpcbox wraps MEOS C function intersection_tpcbox_tpcbox. -func IntersectionTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) *TPCBox { +func IntersectionTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 *TPCBox, _err error) { + C.meos_errno_reset() _cret := C.intersection_tpcbox_tpcbox(box1._inner, box2._inner) - return &TPCBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TPCBox{_inner: _cret}, nil } // ContainsTpcboxTpcbox wraps MEOS C function contains_tpcbox_tpcbox. -func ContainsTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) bool { +func ContainsTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_tpcbox_tpcbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainedTpcboxTpcbox wraps MEOS C function contained_tpcbox_tpcbox. -func ContainedTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) bool { +func ContainedTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_tpcbox_tpcbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverlapsTpcboxTpcbox wraps MEOS C function overlaps_tpcbox_tpcbox. -func OverlapsTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) bool { +func OverlapsTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overlaps_tpcbox_tpcbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // SameTpcboxTpcbox wraps MEOS C function same_tpcbox_tpcbox. -func SameTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) bool { +func SameTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.same_tpcbox_tpcbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AdjacentTpcboxTpcbox wraps MEOS C function adjacent_tpcbox_tpcbox. -func AdjacentTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) bool { +func AdjacentTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.adjacent_tpcbox_tpcbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TpcboxCmp wraps MEOS C function tpcbox_cmp. -func TpcboxCmp(box1 *TPCBox, box2 *TPCBox) int { +func TpcboxCmp(box1 *TPCBox, box2 *TPCBox) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.tpcbox_cmp(box1._inner, box2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TpcboxEq wraps MEOS C function tpcbox_eq. -func TpcboxEq(box1 *TPCBox, box2 *TPCBox) bool { +func TpcboxEq(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tpcbox_eq(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TpcboxNe wraps MEOS C function tpcbox_ne. -func TpcboxNe(box1 *TPCBox, box2 *TPCBox) bool { +func TpcboxNe(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tpcbox_ne(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TpcboxLt wraps MEOS C function tpcbox_lt. -func TpcboxLt(box1 *TPCBox, box2 *TPCBox) bool { +func TpcboxLt(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tpcbox_lt(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TpcboxLe wraps MEOS C function tpcbox_le. -func TpcboxLe(box1 *TPCBox, box2 *TPCBox) bool { +func TpcboxLe(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tpcbox_le(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TpcboxGt wraps MEOS C function tpcbox_gt. -func TpcboxGt(box1 *TPCBox, box2 *TPCBox) bool { +func TpcboxGt(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tpcbox_gt(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TpcboxGe wraps MEOS C function tpcbox_ge. -func TpcboxGe(box1 *TPCBox, box2 *TPCBox) bool { +func TpcboxGe(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.tpcbox_ge(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // LeftTpcboxTpcbox wraps MEOS C function left_tpcbox_tpcbox. -func LeftTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) bool { +func LeftTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.left_tpcbox_tpcbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverleftTpcboxTpcbox wraps MEOS C function overleft_tpcbox_tpcbox. -func OverleftTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) bool { +func OverleftTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overleft_tpcbox_tpcbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // RightTpcboxTpcbox wraps MEOS C function right_tpcbox_tpcbox. -func RightTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) bool { +func RightTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.right_tpcbox_tpcbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverrightTpcboxTpcbox wraps MEOS C function overright_tpcbox_tpcbox. -func OverrightTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) bool { +func OverrightTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overright_tpcbox_tpcbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BelowTpcboxTpcbox wraps MEOS C function below_tpcbox_tpcbox. -func BelowTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) bool { +func BelowTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.below_tpcbox_tpcbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbelowTpcboxTpcbox wraps MEOS C function overbelow_tpcbox_tpcbox. -func OverbelowTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) bool { +func OverbelowTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbelow_tpcbox_tpcbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AboveTpcboxTpcbox wraps MEOS C function above_tpcbox_tpcbox. -func AboveTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) bool { +func AboveTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.above_tpcbox_tpcbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OveraboveTpcboxTpcbox wraps MEOS C function overabove_tpcbox_tpcbox. -func OveraboveTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) bool { +func OveraboveTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overabove_tpcbox_tpcbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // FrontTpcboxTpcbox wraps MEOS C function front_tpcbox_tpcbox. -func FrontTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) bool { +func FrontTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.front_tpcbox_tpcbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverfrontTpcboxTpcbox wraps MEOS C function overfront_tpcbox_tpcbox. -func OverfrontTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) bool { +func OverfrontTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overfront_tpcbox_tpcbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BackTpcboxTpcbox wraps MEOS C function back_tpcbox_tpcbox. -func BackTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) bool { +func BackTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.back_tpcbox_tpcbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbackTpcboxTpcbox wraps MEOS C function overback_tpcbox_tpcbox. -func OverbackTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) bool { +func OverbackTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overback_tpcbox_tpcbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // BeforeTpcboxTpcbox wraps MEOS C function before_tpcbox_tpcbox. -func BeforeTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) bool { +func BeforeTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.before_tpcbox_tpcbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverbeforeTpcboxTpcbox wraps MEOS C function overbefore_tpcbox_tpcbox. -func OverbeforeTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) bool { +func OverbeforeTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overbefore_tpcbox_tpcbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // AfterTpcboxTpcbox wraps MEOS C function after_tpcbox_tpcbox. -func AfterTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) bool { +func AfterTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.after_tpcbox_tpcbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // OverafterTpcboxTpcbox wraps MEOS C function overafter_tpcbox_tpcbox. -func OverafterTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) bool { +func OverafterTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.overafter_tpcbox_tpcbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // EnsureSamePcidTpcbox wraps MEOS C function ensure_same_pcid_tpcbox. -func EnsureSamePcidTpcbox(box1 *TPCBox, box2 *TPCBox) bool { +func EnsureSamePcidTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.ensure_same_pcid_tpcbox(box1._inner, box2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // TpointcloudToTgeompoint wraps MEOS C function tpointcloud_to_tgeompoint. -func TpointcloudToTgeompoint(temp *Temporal) *Temporal { +func TpointcloudToTgeompoint(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpointcloud_to_tgeompoint(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpcpointinstMake wraps MEOS C function tpcpointinst_make. -func TpcpointinstMake(pt *Pcpoint, t int64) *TInstant { +func TpcpointinstMake(pt *Pcpoint, t int64) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tpcpointinst_make(pt._inner, C.TimestampTz(t)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TpcpointseqFromBaseTstzset wraps MEOS C function tpcpointseq_from_base_tstzset. -func TpcpointseqFromBaseTstzset(pt *Pcpoint, s *Set) *TSequence { +func TpcpointseqFromBaseTstzset(pt *Pcpoint, s *Set) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tpcpointseq_from_base_tstzset(pt._inner, s._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TpcpointseqFromBaseTstzspan wraps MEOS C function tpcpointseq_from_base_tstzspan. -func TpcpointseqFromBaseTstzspan(pt *Pcpoint, sp *Span) *TSequence { +func TpcpointseqFromBaseTstzspan(pt *Pcpoint, sp *Span) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tpcpointseq_from_base_tstzspan(pt._inner, sp._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TpcpointseqsetFromBaseTstzspanset wraps MEOS C function tpcpointseqset_from_base_tstzspanset. -func TpcpointseqsetFromBaseTstzspanset(pt *Pcpoint, ss *SpanSet) *TSequenceSet { +func TpcpointseqsetFromBaseTstzspanset(pt *Pcpoint, ss *SpanSet) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tpcpointseqset_from_base_tstzspanset(pt._inner, ss._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TpcpointFromBaseTemp wraps MEOS C function tpcpoint_from_base_temp. -func TpcpointFromBaseTemp(pt *Pcpoint, temp *Temporal) *Temporal { +func TpcpointFromBaseTemp(pt *Pcpoint, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpcpoint_from_base_temp(pt._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpcpointStartValue wraps MEOS C function tpcpoint_start_value. -func TpcpointStartValue(temp *Temporal) *Pcpoint { +func TpcpointStartValue(temp *Temporal) (_r0 *Pcpoint, _err error) { + C.meos_errno_reset() _cret := C.tpcpoint_start_value(temp._inner) - return &Pcpoint{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pcpoint{_inner: _cret}, nil } // TpcpointEndValue wraps MEOS C function tpcpoint_end_value. -func TpcpointEndValue(temp *Temporal) *Pcpoint { +func TpcpointEndValue(temp *Temporal) (_r0 *Pcpoint, _err error) { + C.meos_errno_reset() _cret := C.tpcpoint_end_value(temp._inner) - return &Pcpoint{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pcpoint{_inner: _cret}, nil } // TpcpointValueN wraps MEOS C function tpcpoint_value_n. -func TpcpointValueN(temp *Temporal, n int) (bool, *Pcpoint) { +func TpcpointValueN(temp *Temporal, n int) (_r0 bool, _r1 *Pcpoint, _err error) { var _out_result *C.Pcpoint + C.meos_errno_reset() _cret := C.tpcpoint_value_n(temp._inner, C.int(n), &_out_result) - return bool(_cret), &Pcpoint{_inner: _out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Pcpoint{_inner: _out_result}, nil } // TpcpointValues wraps MEOS C function tpcpoint_values. -func TpcpointValues(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TpcpointValues(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tpcpoint_values(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TpcpointValueAtTimestamptz wraps MEOS C function tpcpoint_value_at_timestamptz. -func TpcpointValueAtTimestamptz(temp *Temporal, t int64, strict bool) (bool, *Pcpoint) { +func TpcpointValueAtTimestamptz(temp *Temporal, t int64, strict bool) (_r0 bool, _r1 *Pcpoint, _err error) { var _out_value *C.Pcpoint + C.meos_errno_reset() _cret := C.tpcpoint_value_at_timestamptz(temp._inner, C.TimestampTz(t), C.bool(strict), &_out_value) - return bool(_cret), &Pcpoint{_inner: _out_value} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Pcpoint{_inner: _out_value}, nil } // TpcpointAtValue wraps MEOS C function tpcpoint_at_value. -func TpcpointAtValue(temp *Temporal, pt *Pcpoint) *Temporal { +func TpcpointAtValue(temp *Temporal, pt *Pcpoint) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpcpoint_at_value(temp._inner, pt._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpcpointMinusValue wraps MEOS C function tpcpoint_minus_value. -func TpcpointMinusValue(temp *Temporal, pt *Pcpoint) *Temporal { +func TpcpointMinusValue(temp *Temporal, pt *Pcpoint) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpcpoint_minus_value(temp._inner, pt._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpcpatchinstMake wraps MEOS C function tpcpatchinst_make. -func TpcpatchinstMake(pa *Pcpatch, t int64) *TInstant { +func TpcpatchinstMake(pa *Pcpatch, t int64) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tpcpatchinst_make(pa._inner, C.TimestampTz(t)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TpcpatchseqFromBaseTstzset wraps MEOS C function tpcpatchseq_from_base_tstzset. -func TpcpatchseqFromBaseTstzset(pa *Pcpatch, s *Set) *TSequence { +func TpcpatchseqFromBaseTstzset(pa *Pcpatch, s *Set) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tpcpatchseq_from_base_tstzset(pa._inner, s._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TpcpatchseqFromBaseTstzspan wraps MEOS C function tpcpatchseq_from_base_tstzspan. -func TpcpatchseqFromBaseTstzspan(pa *Pcpatch, sp *Span) *TSequence { +func TpcpatchseqFromBaseTstzspan(pa *Pcpatch, sp *Span) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tpcpatchseq_from_base_tstzspan(pa._inner, sp._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TpcpatchseqsetFromBaseTstzspanset wraps MEOS C function tpcpatchseqset_from_base_tstzspanset. -func TpcpatchseqsetFromBaseTstzspanset(pa *Pcpatch, ss *SpanSet) *TSequenceSet { +func TpcpatchseqsetFromBaseTstzspanset(pa *Pcpatch, ss *SpanSet) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tpcpatchseqset_from_base_tstzspanset(pa._inner, ss._inner) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TpcpatchFromBaseTemp wraps MEOS C function tpcpatch_from_base_temp. -func TpcpatchFromBaseTemp(pa *Pcpatch, temp *Temporal) *Temporal { +func TpcpatchFromBaseTemp(pa *Pcpatch, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpcpatch_from_base_temp(pa._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpcpatchStartValue wraps MEOS C function tpcpatch_start_value. -func TpcpatchStartValue(temp *Temporal) *Pcpatch { +func TpcpatchStartValue(temp *Temporal) (_r0 *Pcpatch, _err error) { + C.meos_errno_reset() _cret := C.tpcpatch_start_value(temp._inner) - return &Pcpatch{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pcpatch{_inner: _cret}, nil } // TpcpatchEndValue wraps MEOS C function tpcpatch_end_value. -func TpcpatchEndValue(temp *Temporal) *Pcpatch { +func TpcpatchEndValue(temp *Temporal) (_r0 *Pcpatch, _err error) { + C.meos_errno_reset() _cret := C.tpcpatch_end_value(temp._inner) - return &Pcpatch{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pcpatch{_inner: _cret}, nil } // TpcpatchValueN wraps MEOS C function tpcpatch_value_n. -func TpcpatchValueN(temp *Temporal, n int) (bool, *Pcpatch) { +func TpcpatchValueN(temp *Temporal, n int) (_r0 bool, _r1 *Pcpatch, _err error) { var _out_result *C.Pcpatch + C.meos_errno_reset() _cret := C.tpcpatch_value_n(temp._inner, C.int(n), &_out_result) - return bool(_cret), &Pcpatch{_inner: _out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Pcpatch{_inner: _out_result}, nil } // TpcpatchValues wraps MEOS C function tpcpatch_values. -func TpcpatchValues(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TpcpatchValues(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tpcpatch_values(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TpcpatchValueAtTimestamptz wraps MEOS C function tpcpatch_value_at_timestamptz. -func TpcpatchValueAtTimestamptz(temp *Temporal, t int64, strict bool) (bool, *Pcpatch) { +func TpcpatchValueAtTimestamptz(temp *Temporal, t int64, strict bool) (_r0 bool, _r1 *Pcpatch, _err error) { var _out_value *C.Pcpatch + C.meos_errno_reset() _cret := C.tpcpatch_value_at_timestamptz(temp._inner, C.TimestampTz(t), C.bool(strict), &_out_value) - return bool(_cret), &Pcpatch{_inner: _out_value} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Pcpatch{_inner: _out_value}, nil } // TpcpatchAtValue wraps MEOS C function tpcpatch_at_value. -func TpcpatchAtValue(temp *Temporal, pa *Pcpatch) *Temporal { +func TpcpatchAtValue(temp *Temporal, pa *Pcpatch) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpcpatch_at_value(temp._inner, pa._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TpcpatchMinusValue wraps MEOS C function tpcpatch_minus_value. -func TpcpatchMinusValue(temp *Temporal, pa *Pcpatch) *Temporal { +func TpcpatchMinusValue(temp *Temporal, pa *Pcpatch) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpcpatch_minus_value(temp._inner, pa._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // EverEqPcpointTpcpoint wraps MEOS C function ever_eq_pcpoint_tpcpoint. -func EverEqPcpointTpcpoint(pt *Pcpoint, temp *Temporal) int { +func EverEqPcpointTpcpoint(pt *Pcpoint, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_pcpoint_tpcpoint(pt._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTpcpointPcpoint wraps MEOS C function ever_eq_tpcpoint_pcpoint. -func EverEqTpcpointPcpoint(temp *Temporal, pt *Pcpoint) int { +func EverEqTpcpointPcpoint(temp *Temporal, pt *Pcpoint) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_tpcpoint_pcpoint(temp._inner, pt._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTpcpointTpcpoint wraps MEOS C function ever_eq_tpcpoint_tpcpoint. -func EverEqTpcpointTpcpoint(temp1 *Temporal, temp2 *Temporal) int { +func EverEqTpcpointTpcpoint(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_tpcpoint_tpcpoint(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNePcpointTpcpoint wraps MEOS C function ever_ne_pcpoint_tpcpoint. -func EverNePcpointTpcpoint(pt *Pcpoint, temp *Temporal) int { +func EverNePcpointTpcpoint(pt *Pcpoint, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_pcpoint_tpcpoint(pt._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTpcpointPcpoint wraps MEOS C function ever_ne_tpcpoint_pcpoint. -func EverNeTpcpointPcpoint(temp *Temporal, pt *Pcpoint) int { +func EverNeTpcpointPcpoint(temp *Temporal, pt *Pcpoint) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_tpcpoint_pcpoint(temp._inner, pt._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTpcpointTpcpoint wraps MEOS C function ever_ne_tpcpoint_tpcpoint. -func EverNeTpcpointTpcpoint(temp1 *Temporal, temp2 *Temporal) int { +func EverNeTpcpointTpcpoint(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_tpcpoint_tpcpoint(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqPcpointTpcpoint wraps MEOS C function always_eq_pcpoint_tpcpoint. -func AlwaysEqPcpointTpcpoint(pt *Pcpoint, temp *Temporal) int { +func AlwaysEqPcpointTpcpoint(pt *Pcpoint, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_pcpoint_tpcpoint(pt._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTpcpointPcpoint wraps MEOS C function always_eq_tpcpoint_pcpoint. -func AlwaysEqTpcpointPcpoint(temp *Temporal, pt *Pcpoint) int { +func AlwaysEqTpcpointPcpoint(temp *Temporal, pt *Pcpoint) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_tpcpoint_pcpoint(temp._inner, pt._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTpcpointTpcpoint wraps MEOS C function always_eq_tpcpoint_tpcpoint. -func AlwaysEqTpcpointTpcpoint(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysEqTpcpointTpcpoint(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_tpcpoint_tpcpoint(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNePcpointTpcpoint wraps MEOS C function always_ne_pcpoint_tpcpoint. -func AlwaysNePcpointTpcpoint(pt *Pcpoint, temp *Temporal) int { +func AlwaysNePcpointTpcpoint(pt *Pcpoint, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_pcpoint_tpcpoint(pt._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTpcpointPcpoint wraps MEOS C function always_ne_tpcpoint_pcpoint. -func AlwaysNeTpcpointPcpoint(temp *Temporal, pt *Pcpoint) int { +func AlwaysNeTpcpointPcpoint(temp *Temporal, pt *Pcpoint) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_tpcpoint_pcpoint(temp._inner, pt._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTpcpointTpcpoint wraps MEOS C function always_ne_tpcpoint_tpcpoint. -func AlwaysNeTpcpointTpcpoint(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysNeTpcpointTpcpoint(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_tpcpoint_tpcpoint(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqPcpatchTpcpatch wraps MEOS C function ever_eq_pcpatch_tpcpatch. -func EverEqPcpatchTpcpatch(pa *Pcpatch, temp *Temporal) int { +func EverEqPcpatchTpcpatch(pa *Pcpatch, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_pcpatch_tpcpatch(pa._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTpcpatchPcpatch wraps MEOS C function ever_eq_tpcpatch_pcpatch. -func EverEqTpcpatchPcpatch(temp *Temporal, pa *Pcpatch) int { +func EverEqTpcpatchPcpatch(temp *Temporal, pa *Pcpatch) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_tpcpatch_pcpatch(temp._inner, pa._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTpcpatchTpcpatch wraps MEOS C function ever_eq_tpcpatch_tpcpatch. -func EverEqTpcpatchTpcpatch(temp1 *Temporal, temp2 *Temporal) int { +func EverEqTpcpatchTpcpatch(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_tpcpatch_tpcpatch(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNePcpatchTpcpatch wraps MEOS C function ever_ne_pcpatch_tpcpatch. -func EverNePcpatchTpcpatch(pa *Pcpatch, temp *Temporal) int { +func EverNePcpatchTpcpatch(pa *Pcpatch, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_pcpatch_tpcpatch(pa._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTpcpatchPcpatch wraps MEOS C function ever_ne_tpcpatch_pcpatch. -func EverNeTpcpatchPcpatch(temp *Temporal, pa *Pcpatch) int { +func EverNeTpcpatchPcpatch(temp *Temporal, pa *Pcpatch) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_tpcpatch_pcpatch(temp._inner, pa._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTpcpatchTpcpatch wraps MEOS C function ever_ne_tpcpatch_tpcpatch. -func EverNeTpcpatchTpcpatch(temp1 *Temporal, temp2 *Temporal) int { +func EverNeTpcpatchTpcpatch(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_tpcpatch_tpcpatch(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqPcpatchTpcpatch wraps MEOS C function always_eq_pcpatch_tpcpatch. -func AlwaysEqPcpatchTpcpatch(pa *Pcpatch, temp *Temporal) int { +func AlwaysEqPcpatchTpcpatch(pa *Pcpatch, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_pcpatch_tpcpatch(pa._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTpcpatchPcpatch wraps MEOS C function always_eq_tpcpatch_pcpatch. -func AlwaysEqTpcpatchPcpatch(temp *Temporal, pa *Pcpatch) int { +func AlwaysEqTpcpatchPcpatch(temp *Temporal, pa *Pcpatch) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_tpcpatch_pcpatch(temp._inner, pa._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTpcpatchTpcpatch wraps MEOS C function always_eq_tpcpatch_tpcpatch. -func AlwaysEqTpcpatchTpcpatch(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysEqTpcpatchTpcpatch(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_tpcpatch_tpcpatch(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNePcpatchTpcpatch wraps MEOS C function always_ne_pcpatch_tpcpatch. -func AlwaysNePcpatchTpcpatch(pa *Pcpatch, temp *Temporal) int { +func AlwaysNePcpatchTpcpatch(pa *Pcpatch, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_pcpatch_tpcpatch(pa._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTpcpatchPcpatch wraps MEOS C function always_ne_tpcpatch_pcpatch. -func AlwaysNeTpcpatchPcpatch(temp *Temporal, pa *Pcpatch) int { +func AlwaysNeTpcpatchPcpatch(temp *Temporal, pa *Pcpatch) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_tpcpatch_pcpatch(temp._inner, pa._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTpcpatchTpcpatch wraps MEOS C function always_ne_tpcpatch_tpcpatch. -func AlwaysNeTpcpatchTpcpatch(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysNeTpcpatchTpcpatch(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_tpcpatch_tpcpatch(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TeqPcpointTpcpoint wraps MEOS C function teq_pcpoint_tpcpoint. -func TeqPcpointTpcpoint(pt *Pcpoint, temp *Temporal) *Temporal { +func TeqPcpointTpcpoint(pt *Pcpoint, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_pcpoint_tpcpoint(pt._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TeqTpcpointPcpoint wraps MEOS C function teq_tpcpoint_pcpoint. -func TeqTpcpointPcpoint(temp *Temporal, pt *Pcpoint) *Temporal { +func TeqTpcpointPcpoint(temp *Temporal, pt *Pcpoint) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_tpcpoint_pcpoint(temp._inner, pt._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnePcpointTpcpoint wraps MEOS C function tne_pcpoint_tpcpoint. -func TnePcpointTpcpoint(pt *Pcpoint, temp *Temporal) *Temporal { +func TnePcpointTpcpoint(pt *Pcpoint, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_pcpoint_tpcpoint(pt._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneTpcpointPcpoint wraps MEOS C function tne_tpcpoint_pcpoint. -func TneTpcpointPcpoint(temp *Temporal, pt *Pcpoint) *Temporal { +func TneTpcpointPcpoint(temp *Temporal, pt *Pcpoint) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_tpcpoint_pcpoint(temp._inner, pt._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TeqPcpatchTpcpatch wraps MEOS C function teq_pcpatch_tpcpatch. -func TeqPcpatchTpcpatch(pa *Pcpatch, temp *Temporal) *Temporal { +func TeqPcpatchTpcpatch(pa *Pcpatch, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_pcpatch_tpcpatch(pa._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TeqTpcpatchPcpatch wraps MEOS C function teq_tpcpatch_pcpatch. -func TeqTpcpatchPcpatch(temp *Temporal, pa *Pcpatch) *Temporal { +func TeqTpcpatchPcpatch(temp *Temporal, pa *Pcpatch) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_tpcpatch_pcpatch(temp._inner, pa._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnePcpatchTpcpatch wraps MEOS C function tne_pcpatch_tpcpatch. -func TnePcpatchTpcpatch(pa *Pcpatch, temp *Temporal) *Temporal { +func TnePcpatchTpcpatch(pa *Pcpatch, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_pcpatch_tpcpatch(pa._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneTpcpatchPcpatch wraps MEOS C function tne_tpcpatch_pcpatch. -func TneTpcpatchPcpatch(temp *Temporal, pa *Pcpatch) *Temporal { +func TneTpcpatchPcpatch(temp *Temporal, pa *Pcpatch) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_tpcpatch_pcpatch(temp._inner, pa._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // EintersectsTpcpointGeo wraps MEOS C function eintersects_tpcpoint_geo. -func EintersectsTpcpointGeo(temp *Temporal, gs *Geom) bool { +func EintersectsTpcpointGeo(temp *Temporal, gs *Geom) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.eintersects_tpcpoint_geo(temp._inner, gs._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // NadTpcpointGeo wraps MEOS C function nad_tpcpoint_geo. -func NadTpcpointGeo(temp *Temporal, gs *Geom) float64 { +func NadTpcpointGeo(temp *Temporal, gs *Geom) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_tpcpoint_geo(temp._inner, gs._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } diff --git a/functions/meos_meos_pose.go b/functions/meos_meos_pose.go index 6464024..13a65c2 100644 --- a/functions/meos_meos_pose.go +++ b/functions/meos_meos_pose.go @@ -86,902 +86,1406 @@ import ( var _ = unsafe.Pointer(nil) // PoseAsEWKT wraps MEOS C function pose_as_ewkt. -func PoseAsEWKT(pose *Pose, maxdd int) string { +func PoseAsEWKT(pose *Pose, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.pose_as_ewkt(pose._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // PoseAsHexwkb wraps MEOS C function pose_as_hexwkb. -func PoseAsHexwkb(pose *Pose, variant uint8, size_out unsafe.Pointer) string { +func PoseAsHexwkb(pose *Pose, variant uint8, size_out unsafe.Pointer) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.pose_as_hexwkb(pose._inner, C.uint8_t(variant), (*C.size_t)(unsafe.Pointer(size_out))) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // PoseAsText wraps MEOS C function pose_as_text. -func PoseAsText(pose *Pose, maxdd int) string { +func PoseAsText(pose *Pose, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.pose_as_text(pose._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // PoseAsWKB wraps MEOS C function pose_as_wkb. -func PoseAsWKB(pose *Pose, variant uint8, size_out unsafe.Pointer) unsafe.Pointer { +func PoseAsWKB(pose *Pose, variant uint8, size_out unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.pose_as_wkb(pose._inner, C.uint8_t(variant), (*C.size_t)(unsafe.Pointer(size_out))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // PoseFromWKB wraps MEOS C function pose_from_wkb. -func PoseFromWKB(wkb unsafe.Pointer, size uint) *Pose { +func PoseFromWKB(wkb unsafe.Pointer, size uint) (_r0 *Pose, _err error) { + C.meos_errno_reset() _cret := C.pose_from_wkb((*C.uint8_t)(unsafe.Pointer(wkb)), C.size_t(size)) - return &Pose{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil } // PoseFromHexwkb wraps MEOS C function pose_from_hexwkb. -func PoseFromHexwkb(hexwkb string) *Pose { +func PoseFromHexwkb(hexwkb string) (_r0 *Pose, _err error) { _c_hexwkb := C.CString(hexwkb) defer C.free(unsafe.Pointer(_c_hexwkb)) + C.meos_errno_reset() _cret := C.pose_from_hexwkb(_c_hexwkb) - return &Pose{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil } // PoseIn wraps MEOS C function pose_in. -func PoseIn(str string) *Pose { +func PoseIn(str string) (_r0 *Pose, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.pose_in(_c_str) - return &Pose{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil } // PoseOut wraps MEOS C function pose_out. -func PoseOut(pose *Pose, maxdd int) string { +func PoseOut(pose *Pose, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.pose_out(pose._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // PoseFromGeopose wraps MEOS C function pose_from_geopose. -func PoseFromGeopose(json string) *Pose { +func PoseFromGeopose(json string) (_r0 *Pose, _err error) { _c_json := C.CString(json) defer C.free(unsafe.Pointer(_c_json)) + C.meos_errno_reset() _cret := C.pose_from_geopose(_c_json) - return &Pose{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil } // PoseAsGeopose wraps MEOS C function pose_as_geopose. -func PoseAsGeopose(pose *Pose, conformance int, precision int) string { +func PoseAsGeopose(pose *Pose, conformance int, precision int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.pose_as_geopose(pose._inner, C.int(conformance), C.int(precision)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TposeFromGeopose wraps MEOS C function tpose_from_geopose. -func TposeFromGeopose(json string) *Temporal { +func TposeFromGeopose(json string) (_r0 *Temporal, _err error) { _c_json := C.CString(json) defer C.free(unsafe.Pointer(_c_json)) + C.meos_errno_reset() _cret := C.tpose_from_geopose(_c_json) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TposeAsGeopose wraps MEOS C function tpose_as_geopose. -func TposeAsGeopose(temp *Temporal, conformance int, precision int) string { +func TposeAsGeopose(temp *Temporal, conformance int, precision int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.tpose_as_geopose(temp._inner, C.int(conformance), C.int(precision)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TposeAsGeoposeStreamHeader wraps MEOS C function tpose_as_geopose_stream_header. -func TposeAsGeoposeStreamHeader(temp *Temporal, precision int) string { +func TposeAsGeoposeStreamHeader(temp *Temporal, precision int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.tpose_as_geopose_stream_header(temp._inner, C.int(precision)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TposeAsGeoposeStreamElement wraps MEOS C function tpose_as_geopose_stream_element. -func TposeAsGeoposeStreamElement(temp *Temporal, inst *TInstant, precision int) string { +func TposeAsGeoposeStreamElement(temp *Temporal, inst *TInstant, precision int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.tpose_as_geopose_stream_element(temp._inner, inst._inner, C.int(precision)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // PoseApplyGeo wraps MEOS C function pose_apply_geo. -func PoseApplyGeo(pose *Pose, body *Geom) *Geom { +func PoseApplyGeo(pose *Pose, body *Geom) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.pose_apply_geo(pose._inner, body._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // TposeApplyGeo wraps MEOS C function tpose_apply_geo. -func TposeApplyGeo(temp *Temporal, body *Geom) *Temporal { +func TposeApplyGeo(temp *Temporal, body *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpose_apply_geo(temp._inner, body._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // PoseCopy wraps MEOS C function pose_copy. -func PoseCopy(pose *Pose) *Pose { +func PoseCopy(pose *Pose) (_r0 *Pose, _err error) { + C.meos_errno_reset() _cret := C.pose_copy(pose._inner) - return &Pose{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil } // PoseMake2d wraps MEOS C function pose_make_2d. -func PoseMake2d(x float64, y float64, theta float64, geodetic bool, srid int32) *Pose { +func PoseMake2d(x float64, y float64, theta float64, geodetic bool, srid int32) (_r0 *Pose, _err error) { + C.meos_errno_reset() _cret := C.pose_make_2d(C.double(x), C.double(y), C.double(theta), C.bool(geodetic), C.int32_t(srid)) - return &Pose{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil } // PoseMake3d wraps MEOS C function pose_make_3d. -func PoseMake3d(x float64, y float64, z float64, W float64, X float64, Y float64, Z float64, geodetic bool, srid int32) *Pose { +func PoseMake3d(x float64, y float64, z float64, W float64, X float64, Y float64, Z float64, geodetic bool, srid int32) (_r0 *Pose, _err error) { + C.meos_errno_reset() _cret := C.pose_make_3d(C.double(x), C.double(y), C.double(z), C.double(W), C.double(X), C.double(Y), C.double(Z), C.bool(geodetic), C.int32_t(srid)) - return &Pose{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil } // PoseMakePoint2d wraps MEOS C function pose_make_point2d. -func PoseMakePoint2d(gs *Geom, theta float64) *Pose { +func PoseMakePoint2d(gs *Geom, theta float64) (_r0 *Pose, _err error) { + C.meos_errno_reset() _cret := C.pose_make_point2d(gs._inner, C.double(theta)) - return &Pose{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil } // PoseMakePoint3d wraps MEOS C function pose_make_point3d. -func PoseMakePoint3d(gs *Geom, W float64, X float64, Y float64, Z float64) *Pose { +func PoseMakePoint3d(gs *Geom, W float64, X float64, Y float64, Z float64) (_r0 *Pose, _err error) { + C.meos_errno_reset() _cret := C.pose_make_point3d(gs._inner, C.double(W), C.double(X), C.double(Y), C.double(Z)) - return &Pose{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil } // PoseToPoint wraps MEOS C function pose_to_point. -func PoseToPoint(pose *Pose) *Geom { +func PoseToPoint(pose *Pose) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.pose_to_point(pose._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // PoseToSTBOX wraps MEOS C function pose_to_stbox. -func PoseToSTBOX(pose *Pose) *STBox { +func PoseToSTBOX(pose *Pose) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.pose_to_stbox(pose._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // PoseHash wraps MEOS C function pose_hash. -func PoseHash(pose *Pose) uint32 { +func PoseHash(pose *Pose) (_r0 uint32, _err error) { + C.meos_errno_reset() _cret := C.pose_hash(pose._inner) - return uint32(_cret) + if _err = meosError(); _err != nil { + return + } + return uint32(_cret), nil } // PoseHashExtended wraps MEOS C function pose_hash_extended. -func PoseHashExtended(pose *Pose, seed uint64) uint64 { +func PoseHashExtended(pose *Pose, seed uint64) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.pose_hash_extended(pose._inner, C.uint64_t(seed)) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // PoseOrientation wraps MEOS C function pose_orientation. -func PoseOrientation(pose *Pose, count unsafe.Pointer) unsafe.Pointer { +func PoseOrientation(pose *Pose, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.pose_orientation(pose._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // PoseRotation wraps MEOS C function pose_rotation. -func PoseRotation(pose *Pose) float64 { +func PoseRotation(pose *Pose) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.pose_rotation(pose._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // PoseYaw wraps MEOS C function pose_yaw. -func PoseYaw(pose *Pose) float64 { +func PoseYaw(pose *Pose) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.pose_yaw(pose._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // PosePitch wraps MEOS C function pose_pitch. -func PosePitch(pose *Pose) float64 { +func PosePitch(pose *Pose) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.pose_pitch(pose._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // PoseRoll wraps MEOS C function pose_roll. -func PoseRoll(pose *Pose) float64 { +func PoseRoll(pose *Pose) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.pose_roll(pose._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // PoseAngularDistance wraps MEOS C function pose_angular_distance. -func PoseAngularDistance(pose1 *Pose, pose2 *Pose) float64 { +func PoseAngularDistance(pose1 *Pose, pose2 *Pose) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.pose_angular_distance(pose1._inner, pose2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // PoseNormalize wraps MEOS C function pose_normalize. -func PoseNormalize(pose *Pose) *Pose { +func PoseNormalize(pose *Pose) (_r0 *Pose, _err error) { + C.meos_errno_reset() _cret := C.pose_normalize(pose._inner) - return &Pose{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil } // PoseRound wraps MEOS C function pose_round. -func PoseRound(pose *Pose, maxdd int) *Pose { +func PoseRound(pose *Pose, maxdd int) (_r0 *Pose, _err error) { + C.meos_errno_reset() _cret := C.pose_round(pose._inner, C.int(maxdd)) - return &Pose{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil } // PosearrRound wraps MEOS C function posearr_round. -func PosearrRound(posearr unsafe.Pointer, count int, maxdd int) unsafe.Pointer { +func PosearrRound(posearr unsafe.Pointer, count int, maxdd int) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.posearr_round((**C.Pose)(unsafe.Pointer(posearr)), C.int(count), C.int(maxdd)) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // PoseSetSRID wraps MEOS C function pose_set_srid. -func PoseSetSRID(pose *Pose, srid int32) *Pose { +func PoseSetSRID(pose *Pose, srid int32) (_r0 *Pose, _err error) { + C.meos_errno_reset() _cret := C.pose_set_srid(pose._inner, C.int32_t(srid)) - return &Pose{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil } // PoseSRID wraps MEOS C function pose_srid. -func PoseSRID(pose *Pose) int32 { +func PoseSRID(pose *Pose) (_r0 int32, _err error) { + C.meos_errno_reset() _cret := C.pose_srid(pose._inner) - return int32(_cret) + if _err = meosError(); _err != nil { + return + } + return int32(_cret), nil } // PoseTransform wraps MEOS C function pose_transform. -func PoseTransform(pose *Pose, srid int32) *Pose { +func PoseTransform(pose *Pose, srid int32) (_r0 *Pose, _err error) { + C.meos_errno_reset() _cret := C.pose_transform(pose._inner, C.int32_t(srid)) - return &Pose{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil } // PoseTransformPipeline wraps MEOS C function pose_transform_pipeline. -func PoseTransformPipeline(pose *Pose, pipelinestr string, srid int32, is_forward bool) *Pose { +func PoseTransformPipeline(pose *Pose, pipelinestr string, srid int32, is_forward bool) (_r0 *Pose, _err error) { _c_pipelinestr := C.CString(pipelinestr) defer C.free(unsafe.Pointer(_c_pipelinestr)) + C.meos_errno_reset() _cret := C.pose_transform_pipeline(pose._inner, _c_pipelinestr, C.int32_t(srid), C.bool(is_forward)) - return &Pose{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil } // PoseTstzspanToSTBOX wraps MEOS C function pose_tstzspan_to_stbox. -func PoseTstzspanToSTBOX(pose *Pose, s *Span) *STBox { +func PoseTstzspanToSTBOX(pose *Pose, s *Span) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.pose_tstzspan_to_stbox(pose._inner, s._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // PoseTimestamptzToSTBOX wraps MEOS C function pose_timestamptz_to_stbox. -func PoseTimestamptzToSTBOX(pose *Pose, t int64) *STBox { +func PoseTimestamptzToSTBOX(pose *Pose, t int64) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.pose_timestamptz_to_stbox(pose._inner, C.TimestampTz(t)) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // DistancePoseGeo wraps MEOS C function distance_pose_geo. -func DistancePoseGeo(pose *Pose, gs *Geom) float64 { +func DistancePoseGeo(pose *Pose, gs *Geom) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.distance_pose_geo(pose._inner, gs._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // DistancePosePose wraps MEOS C function distance_pose_pose. -func DistancePosePose(pose1 *Pose, pose2 *Pose) float64 { +func DistancePosePose(pose1 *Pose, pose2 *Pose) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.distance_pose_pose(pose1._inner, pose2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // DistancePoseSTBOX wraps MEOS C function distance_pose_stbox. -func DistancePoseSTBOX(pose *Pose, box *STBox) float64 { +func DistancePoseSTBOX(pose *Pose, box *STBox) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.distance_pose_stbox(pose._inner, box._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // PoseCmp wraps MEOS C function pose_cmp. -func PoseCmp(pose1 *Pose, pose2 *Pose) int { +func PoseCmp(pose1 *Pose, pose2 *Pose) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.pose_cmp(pose1._inner, pose2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // PoseEq wraps MEOS C function pose_eq. -func PoseEq(pose1 *Pose, pose2 *Pose) bool { +func PoseEq(pose1 *Pose, pose2 *Pose) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pose_eq(pose1._inner, pose2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PoseGe wraps MEOS C function pose_ge. -func PoseGe(pose1 *Pose, pose2 *Pose) bool { +func PoseGe(pose1 *Pose, pose2 *Pose) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pose_ge(pose1._inner, pose2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PoseGt wraps MEOS C function pose_gt. -func PoseGt(pose1 *Pose, pose2 *Pose) bool { +func PoseGt(pose1 *Pose, pose2 *Pose) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pose_gt(pose1._inner, pose2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PoseLe wraps MEOS C function pose_le. -func PoseLe(pose1 *Pose, pose2 *Pose) bool { +func PoseLe(pose1 *Pose, pose2 *Pose) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pose_le(pose1._inner, pose2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PoseLt wraps MEOS C function pose_lt. -func PoseLt(pose1 *Pose, pose2 *Pose) bool { +func PoseLt(pose1 *Pose, pose2 *Pose) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pose_lt(pose1._inner, pose2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PoseNe wraps MEOS C function pose_ne. -func PoseNe(pose1 *Pose, pose2 *Pose) bool { +func PoseNe(pose1 *Pose, pose2 *Pose) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pose_ne(pose1._inner, pose2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PoseNsame wraps MEOS C function pose_nsame. -func PoseNsame(pose1 *Pose, pose2 *Pose) bool { +func PoseNsame(pose1 *Pose, pose2 *Pose) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pose_nsame(pose1._inner, pose2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PoseSame wraps MEOS C function pose_same. -func PoseSame(pose1 *Pose, pose2 *Pose) bool { +func PoseSame(pose1 *Pose, pose2 *Pose) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.pose_same(pose1._inner, pose2._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // PosesetIn wraps MEOS C function poseset_in. -func PosesetIn(str string) *Set { +func PosesetIn(str string) (_r0 *Set, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.poseset_in(_c_str) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // PosesetOut wraps MEOS C function poseset_out. -func PosesetOut(s *Set, maxdd int) string { +func PosesetOut(s *Set, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.poseset_out(s._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // PosesetMake wraps MEOS C function poseset_make. -func PosesetMake(values unsafe.Pointer, count int) *Set { +func PosesetMake(values unsafe.Pointer, count int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.poseset_make((**C.Pose)(unsafe.Pointer(values)), C.int(count)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // PoseToSet wraps MEOS C function pose_to_set. -func PoseToSet(pose *Pose) *Set { +func PoseToSet(pose *Pose) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.pose_to_set(pose._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // PosesetEndValue wraps MEOS C function poseset_end_value. -func PosesetEndValue(s *Set) *Pose { +func PosesetEndValue(s *Set) (_r0 *Pose, _err error) { + C.meos_errno_reset() _cret := C.poseset_end_value(s._inner) - return &Pose{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil } // PosesetStartValue wraps MEOS C function poseset_start_value. -func PosesetStartValue(s *Set) *Pose { +func PosesetStartValue(s *Set) (_r0 *Pose, _err error) { + C.meos_errno_reset() _cret := C.poseset_start_value(s._inner) - return &Pose{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil } // PosesetValueN wraps MEOS C function poseset_value_n. -func PosesetValueN(s *Set, n int) (bool, *Pose) { +func PosesetValueN(s *Set, n int) (_r0 bool, _r1 *Pose, _err error) { var _out_result *C.Pose + C.meos_errno_reset() _cret := C.poseset_value_n(s._inner, C.int(n), &_out_result) - return bool(_cret), &Pose{_inner: _out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Pose{_inner: _out_result}, nil } // PosesetValues wraps MEOS C function poseset_values. -func PosesetValues(s *Set, count unsafe.Pointer) unsafe.Pointer { +func PosesetValues(s *Set, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.poseset_values(s._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // ContainedPoseSet wraps MEOS C function contained_pose_set. -func ContainedPoseSet(pose *Pose, s *Set) bool { +func ContainedPoseSet(pose *Pose, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contained_pose_set(pose._inner, s._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // ContainsSetPose wraps MEOS C function contains_set_pose. -func ContainsSetPose(s *Set, pose *Pose) bool { +func ContainsSetPose(s *Set, pose *Pose) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.contains_set_pose(s._inner, pose._inner) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // IntersectionPoseSet wraps MEOS C function intersection_pose_set. -func IntersectionPoseSet(pose *Pose, s *Set) *Set { +func IntersectionPoseSet(pose *Pose, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_pose_set(pose._inner, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // IntersectionSetPose wraps MEOS C function intersection_set_pose. -func IntersectionSetPose(s *Set, pose *Pose) *Set { +func IntersectionSetPose(s *Set, pose *Pose) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.intersection_set_pose(s._inner, pose._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusPoseSet wraps MEOS C function minus_pose_set. -func MinusPoseSet(pose *Pose, s *Set) *Set { +func MinusPoseSet(pose *Pose, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_pose_set(pose._inner, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // MinusSetPose wraps MEOS C function minus_set_pose. -func MinusSetPose(s *Set, pose *Pose) *Set { +func MinusSetPose(s *Set, pose *Pose) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.minus_set_pose(s._inner, pose._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // PoseUnionTransfn wraps MEOS C function pose_union_transfn. -func PoseUnionTransfn(state *Set, pose *Pose) *Set { +func PoseUnionTransfn(state *Set, pose *Pose) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.pose_union_transfn(state._inner, pose._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionPoseSet wraps MEOS C function union_pose_set. -func UnionPoseSet(pose *Pose, s *Set) *Set { +func UnionPoseSet(pose *Pose, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_pose_set(pose._inner, s._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // UnionSetPose wraps MEOS C function union_set_pose. -func UnionSetPose(s *Set, pose *Pose) *Set { +func UnionSetPose(s *Set, pose *Pose) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.gunion_set_pose(s._inner, pose._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TposeFromMFJSON wraps MEOS C function tpose_from_mfjson. -func TposeFromMFJSON(str string) *Temporal { +func TposeFromMFJSON(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tpose_from_mfjson(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TposeIn wraps MEOS C function tpose_in. -func TposeIn(str string) *Temporal { +func TposeIn(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tpose_in(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TposeinstMake wraps MEOS C function tposeinst_make. -func TposeinstMake(pose *Pose, t int64) *TInstant { +func TposeinstMake(pose *Pose, t int64) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tposeinst_make(pose._inner, C.TimestampTz(t)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TposeFromBaseTemp wraps MEOS C function tpose_from_base_temp. -func TposeFromBaseTemp(pose *Pose, temp *Temporal) *Temporal { +func TposeFromBaseTemp(pose *Pose, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpose_from_base_temp(pose._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TposeseqFromBaseTstzset wraps MEOS C function tposeseq_from_base_tstzset. -func TposeseqFromBaseTstzset(pose *Pose, s *Set) *TSequence { +func TposeseqFromBaseTstzset(pose *Pose, s *Set) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tposeseq_from_base_tstzset(pose._inner, s._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TposeseqFromBaseTstzspan wraps MEOS C function tposeseq_from_base_tstzspan. -func TposeseqFromBaseTstzspan(pose *Pose, s *Span, interp Interpolation) *TSequence { +func TposeseqFromBaseTstzspan(pose *Pose, s *Span, interp Interpolation) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tposeseq_from_base_tstzspan(pose._inner, s._inner, C.interpType(interp)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TposeseqsetFromBaseTstzspanset wraps MEOS C function tposeseqset_from_base_tstzspanset. -func TposeseqsetFromBaseTstzspanset(pose *Pose, ss *SpanSet, interp Interpolation) *TSequenceSet { +func TposeseqsetFromBaseTstzspanset(pose *Pose, ss *SpanSet, interp Interpolation) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tposeseqset_from_base_tstzspanset(pose._inner, ss._inner, C.interpType(interp)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TposeMake wraps MEOS C function tpose_make. -func TposeMake(tpoint *Temporal, tradius *Temporal) *Temporal { +func TposeMake(tpoint *Temporal, tradius *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpose_make(tpoint._inner, tradius._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TposeToTpoint wraps MEOS C function tpose_to_tpoint. -func TposeToTpoint(temp *Temporal) *Temporal { +func TposeToTpoint(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpose_to_tpoint(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TposeEndValue wraps MEOS C function tpose_end_value. -func TposeEndValue(temp *Temporal) *Pose { +func TposeEndValue(temp *Temporal) (_r0 *Pose, _err error) { + C.meos_errno_reset() _cret := C.tpose_end_value(temp._inner) - return &Pose{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil } // TposePoints wraps MEOS C function tpose_points. -func TposePoints(temp *Temporal) *Set { +func TposePoints(temp *Temporal) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.tpose_points(temp._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TposeRotation wraps MEOS C function tpose_rotation. -func TposeRotation(temp *Temporal) *Temporal { +func TposeRotation(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpose_rotation(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TposeYaw wraps MEOS C function tpose_yaw. -func TposeYaw(temp *Temporal) *Temporal { +func TposeYaw(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpose_yaw(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TposePitch wraps MEOS C function tpose_pitch. -func TposePitch(temp *Temporal) *Temporal { +func TposePitch(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpose_pitch(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TposeRoll wraps MEOS C function tpose_roll. -func TposeRoll(temp *Temporal) *Temporal { +func TposeRoll(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpose_roll(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TposeSpeed wraps MEOS C function tpose_speed. -func TposeSpeed(temp *Temporal) *Temporal { +func TposeSpeed(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpose_speed(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TposeAngularSpeed wraps MEOS C function tpose_angular_speed. -func TposeAngularSpeed(temp *Temporal) *Temporal { +func TposeAngularSpeed(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpose_angular_speed(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TposeStartValue wraps MEOS C function tpose_start_value. -func TposeStartValue(temp *Temporal) *Pose { +func TposeStartValue(temp *Temporal) (_r0 *Pose, _err error) { + C.meos_errno_reset() _cret := C.tpose_start_value(temp._inner) - return &Pose{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil } // TposeTrajectory wraps MEOS C function tpose_trajectory. -func TposeTrajectory(temp *Temporal) *Geom { +func TposeTrajectory(temp *Temporal) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.tpose_trajectory(temp._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // TposeValueAtTimestamptz wraps MEOS C function tpose_value_at_timestamptz. -func TposeValueAtTimestamptz(temp *Temporal, t int64, strict bool) (bool, *Pose) { +func TposeValueAtTimestamptz(temp *Temporal, t int64, strict bool) (_r0 bool, _r1 *Pose, _err error) { var _out_result *C.Pose + C.meos_errno_reset() _cret := C.tpose_value_at_timestamptz(temp._inner, C.TimestampTz(t), C.bool(strict), &_out_result) - return bool(_cret), &Pose{_inner: _out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Pose{_inner: _out_result}, nil } // TposeValueN wraps MEOS C function tpose_value_n. -func TposeValueN(temp *Temporal, n int) (bool, *Pose) { +func TposeValueN(temp *Temporal, n int) (_r0 bool, _r1 *Pose, _err error) { var _out_result *C.Pose + C.meos_errno_reset() _cret := C.tpose_value_n(temp._inner, C.int(n), &_out_result) - return bool(_cret), &Pose{_inner: _out_result} + if _err = meosError(); _err != nil { + return + } + return bool(_cret), &Pose{_inner: _out_result}, nil } // TposeValues wraps MEOS C function tpose_values. -func TposeValues(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TposeValues(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tpose_values(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TposeAtGeom wraps MEOS C function tpose_at_geom. -func TposeAtGeom(temp *Temporal, gs *Geom) *Temporal { +func TposeAtGeom(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpose_at_geom(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TposeAtSTBOX wraps MEOS C function tpose_at_stbox. -func TposeAtSTBOX(temp *Temporal, box *STBox, border_inc bool) *Temporal { +func TposeAtSTBOX(temp *Temporal, box *STBox, border_inc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpose_at_stbox(temp._inner, box._inner, C.bool(border_inc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TposeAtPose wraps MEOS C function tpose_at_pose. -func TposeAtPose(temp *Temporal, pose *Pose) *Temporal { +func TposeAtPose(temp *Temporal, pose *Pose) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpose_at_pose(temp._inner, pose._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TposeMinusGeom wraps MEOS C function tpose_minus_geom. -func TposeMinusGeom(temp *Temporal, gs *Geom) *Temporal { +func TposeMinusGeom(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpose_minus_geom(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TposeMinusPose wraps MEOS C function tpose_minus_pose. -func TposeMinusPose(temp *Temporal, pose *Pose) *Temporal { +func TposeMinusPose(temp *Temporal, pose *Pose) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpose_minus_pose(temp._inner, pose._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TposeMinusSTBOX wraps MEOS C function tpose_minus_stbox. -func TposeMinusSTBOX(temp *Temporal, box *STBox, border_inc bool) *Temporal { +func TposeMinusSTBOX(temp *Temporal, box *STBox, border_inc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tpose_minus_stbox(temp._inner, box._inner, C.bool(border_inc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdistanceTposePose wraps MEOS C function tdistance_tpose_pose. -func TdistanceTposePose(temp *Temporal, pose *Pose) *Temporal { +func TdistanceTposePose(temp *Temporal, pose *Pose) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdistance_tpose_pose(temp._inner, pose._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdistanceTposeGeo wraps MEOS C function tdistance_tpose_geo. -func TdistanceTposeGeo(temp *Temporal, gs *Geom) *Temporal { +func TdistanceTposeGeo(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdistance_tpose_geo(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdistanceTposeTpose wraps MEOS C function tdistance_tpose_tpose. -func TdistanceTposeTpose(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TdistanceTposeTpose(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdistance_tpose_tpose(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // NadTposeGeo wraps MEOS C function nad_tpose_geo. -func NadTposeGeo(temp *Temporal, gs *Geom) float64 { +func NadTposeGeo(temp *Temporal, gs *Geom) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_tpose_geo(temp._inner, gs._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NadTposePose wraps MEOS C function nad_tpose_pose. -func NadTposePose(temp *Temporal, pose *Pose) float64 { +func NadTposePose(temp *Temporal, pose *Pose) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_tpose_pose(temp._inner, pose._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NadTposeSTBOX wraps MEOS C function nad_tpose_stbox. -func NadTposeSTBOX(temp *Temporal, box *STBox) float64 { +func NadTposeSTBOX(temp *Temporal, box *STBox) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_tpose_stbox(temp._inner, box._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NadTposeTpose wraps MEOS C function nad_tpose_tpose. -func NadTposeTpose(temp1 *Temporal, temp2 *Temporal) float64 { +func NadTposeTpose(temp1 *Temporal, temp2 *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_tpose_tpose(temp1._inner, temp2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NaiTposeGeo wraps MEOS C function nai_tpose_geo. -func NaiTposeGeo(temp *Temporal, gs *Geom) *TInstant { +func NaiTposeGeo(temp *Temporal, gs *Geom) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.nai_tpose_geo(temp._inner, gs._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // NaiTposePose wraps MEOS C function nai_tpose_pose. -func NaiTposePose(temp *Temporal, pose *Pose) *TInstant { +func NaiTposePose(temp *Temporal, pose *Pose) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.nai_tpose_pose(temp._inner, pose._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // NaiTposeTpose wraps MEOS C function nai_tpose_tpose. -func NaiTposeTpose(temp1 *Temporal, temp2 *Temporal) *TInstant { +func NaiTposeTpose(temp1 *Temporal, temp2 *Temporal) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.nai_tpose_tpose(temp1._inner, temp2._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // ShortestlineTposeGeo wraps MEOS C function shortestline_tpose_geo. -func ShortestlineTposeGeo(temp *Temporal, gs *Geom) *Geom { +func ShortestlineTposeGeo(temp *Temporal, gs *Geom) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.shortestline_tpose_geo(temp._inner, gs._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // ShortestlineTposePose wraps MEOS C function shortestline_tpose_pose. -func ShortestlineTposePose(temp *Temporal, pose *Pose) *Geom { +func ShortestlineTposePose(temp *Temporal, pose *Pose) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.shortestline_tpose_pose(temp._inner, pose._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // ShortestlineTposeTpose wraps MEOS C function shortestline_tpose_tpose. -func ShortestlineTposeTpose(temp1 *Temporal, temp2 *Temporal) *Geom { +func ShortestlineTposeTpose(temp1 *Temporal, temp2 *Temporal) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.shortestline_tpose_tpose(temp1._inner, temp2._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // AlwaysEqPoseTpose wraps MEOS C function always_eq_pose_tpose. -func AlwaysEqPoseTpose(pose *Pose, temp *Temporal) int { +func AlwaysEqPoseTpose(pose *Pose, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_pose_tpose(pose._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTposePose wraps MEOS C function always_eq_tpose_pose. -func AlwaysEqTposePose(temp *Temporal, pose *Pose) int { +func AlwaysEqTposePose(temp *Temporal, pose *Pose) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_tpose_pose(temp._inner, pose._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTposeTpose wraps MEOS C function always_eq_tpose_tpose. -func AlwaysEqTposeTpose(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysEqTposeTpose(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_tpose_tpose(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNePoseTpose wraps MEOS C function always_ne_pose_tpose. -func AlwaysNePoseTpose(pose *Pose, temp *Temporal) int { +func AlwaysNePoseTpose(pose *Pose, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_pose_tpose(pose._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTposePose wraps MEOS C function always_ne_tpose_pose. -func AlwaysNeTposePose(temp *Temporal, pose *Pose) int { +func AlwaysNeTposePose(temp *Temporal, pose *Pose) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_tpose_pose(temp._inner, pose._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTposeTpose wraps MEOS C function always_ne_tpose_tpose. -func AlwaysNeTposeTpose(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysNeTposeTpose(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_tpose_tpose(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqPoseTpose wraps MEOS C function ever_eq_pose_tpose. -func EverEqPoseTpose(pose *Pose, temp *Temporal) int { +func EverEqPoseTpose(pose *Pose, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_pose_tpose(pose._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTposePose wraps MEOS C function ever_eq_tpose_pose. -func EverEqTposePose(temp *Temporal, pose *Pose) int { +func EverEqTposePose(temp *Temporal, pose *Pose) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_tpose_pose(temp._inner, pose._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTposeTpose wraps MEOS C function ever_eq_tpose_tpose. -func EverEqTposeTpose(temp1 *Temporal, temp2 *Temporal) int { +func EverEqTposeTpose(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_tpose_tpose(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNePoseTpose wraps MEOS C function ever_ne_pose_tpose. -func EverNePoseTpose(pose *Pose, temp *Temporal) int { +func EverNePoseTpose(pose *Pose, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_pose_tpose(pose._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTposePose wraps MEOS C function ever_ne_tpose_pose. -func EverNeTposePose(temp *Temporal, pose *Pose) int { +func EverNeTposePose(temp *Temporal, pose *Pose) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_tpose_pose(temp._inner, pose._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTposeTpose wraps MEOS C function ever_ne_tpose_tpose. -func EverNeTposeTpose(temp1 *Temporal, temp2 *Temporal) int { +func EverNeTposeTpose(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_tpose_tpose(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TeqPoseTpose wraps MEOS C function teq_pose_tpose. -func TeqPoseTpose(pose *Pose, temp *Temporal) *Temporal { +func TeqPoseTpose(pose *Pose, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_pose_tpose(pose._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TeqTposePose wraps MEOS C function teq_tpose_pose. -func TeqTposePose(temp *Temporal, pose *Pose) *Temporal { +func TeqTposePose(temp *Temporal, pose *Pose) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_tpose_pose(temp._inner, pose._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TnePoseTpose wraps MEOS C function tne_pose_tpose. -func TnePoseTpose(pose *Pose, temp *Temporal) *Temporal { +func TnePoseTpose(pose *Pose, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_pose_tpose(pose._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneTposePose wraps MEOS C function tne_tpose_pose. -func TneTposePose(temp *Temporal, pose *Pose) *Temporal { +func TneTposePose(temp *Temporal, pose *Pose) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_tpose_pose(temp._inner, pose._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } diff --git a/functions/meos_meos_quadbin.go b/functions/meos_meos_quadbin.go index a6ebef3..662bed6 100644 --- a/functions/meos_meos_quadbin.go +++ b/functions/meos_meos_quadbin.go @@ -86,479 +86,743 @@ import ( var _ = unsafe.Pointer(nil) // QuadbinIn wraps MEOS C function quadbin_in. -func QuadbinIn(str string) uint64 { +func QuadbinIn(str string) (_r0 uint64, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.quadbin_in(_c_str) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // QuadbinEq wraps MEOS C function quadbin_eq. -func QuadbinEq(a uint64, b uint64) bool { +func QuadbinEq(a uint64, b uint64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.quadbin_eq(C.uint64_t(a), C.uint64_t(b)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // QuadbinNe wraps MEOS C function quadbin_ne. -func QuadbinNe(a uint64, b uint64) bool { +func QuadbinNe(a uint64, b uint64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.quadbin_ne(C.uint64_t(a), C.uint64_t(b)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // QuadbinLt wraps MEOS C function quadbin_lt. -func QuadbinLt(a uint64, b uint64) bool { +func QuadbinLt(a uint64, b uint64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.quadbin_lt(C.uint64_t(a), C.uint64_t(b)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // QuadbinLe wraps MEOS C function quadbin_le. -func QuadbinLe(a uint64, b uint64) bool { +func QuadbinLe(a uint64, b uint64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.quadbin_le(C.uint64_t(a), C.uint64_t(b)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // QuadbinGt wraps MEOS C function quadbin_gt. -func QuadbinGt(a uint64, b uint64) bool { +func QuadbinGt(a uint64, b uint64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.quadbin_gt(C.uint64_t(a), C.uint64_t(b)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // QuadbinGe wraps MEOS C function quadbin_ge. -func QuadbinGe(a uint64, b uint64) bool { +func QuadbinGe(a uint64, b uint64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.quadbin_ge(C.uint64_t(a), C.uint64_t(b)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // QuadbinCmp wraps MEOS C function quadbin_cmp. -func QuadbinCmp(a uint64, b uint64) int { +func QuadbinCmp(a uint64, b uint64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.quadbin_cmp(C.uint64_t(a), C.uint64_t(b)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // QuadbinHash wraps MEOS C function quadbin_hash. -func QuadbinHash(cell uint64) uint32 { +func QuadbinHash(cell uint64) (_r0 uint32, _err error) { + C.meos_errno_reset() _cret := C.quadbin_hash(C.uint64_t(cell)) - return uint32(_cret) + if _err = meosError(); _err != nil { + return + } + return uint32(_cret), nil } // QuadbinHashExtended wraps MEOS C function quadbin_hash_extended. -func QuadbinHashExtended(cell uint64, seed uint64) uint64 { +func QuadbinHashExtended(cell uint64, seed uint64) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.quadbin_hash_extended(C.uint64_t(cell), C.uint64_t(seed)) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // QuadbinIsValidIndex wraps MEOS C function quadbin_is_valid_index. -func QuadbinIsValidIndex(index uint64) bool { +func QuadbinIsValidIndex(index uint64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.quadbin_is_valid_index(C.uint64_t(index)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // QuadbinIsValidCell wraps MEOS C function quadbin_is_valid_cell. -func QuadbinIsValidCell(cell uint64) bool { +func QuadbinIsValidCell(cell uint64) (_r0 bool, _err error) { + C.meos_errno_reset() _cret := C.quadbin_is_valid_cell(C.uint64_t(cell)) - return bool(_cret) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // QuadbinTileToCell wraps MEOS C function quadbin_tile_to_cell. -func QuadbinTileToCell(x uint32, y uint32, z uint32) uint64 { +func QuadbinTileToCell(x uint32, y uint32, z uint32) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.quadbin_tile_to_cell(C.uint32_t(x), C.uint32_t(y), C.uint32_t(z)) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // QuadbinCellToTile wraps MEOS C function quadbin_cell_to_tile. -func QuadbinCellToTile(cell uint64, x unsafe.Pointer, y unsafe.Pointer, z unsafe.Pointer) bool { +func QuadbinCellToTile(cell uint64, x unsafe.Pointer, y unsafe.Pointer, z unsafe.Pointer) (_r0 bool, _err error) { + C.meos_errno_reset() _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) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil } // QuadbinGetResolution wraps MEOS C function quadbin_get_resolution. -func QuadbinGetResolution(cell uint64) uint32 { +func QuadbinGetResolution(cell uint64) (_r0 uint32, _err error) { + C.meos_errno_reset() _cret := C.quadbin_get_resolution(C.uint64_t(cell)) - return uint32(_cret) + if _err = meosError(); _err != nil { + return + } + return uint32(_cret), nil } // QuadbinCellToParent wraps MEOS C function quadbin_cell_to_parent. -func QuadbinCellToParent(cell uint64, parent_resolution uint32) uint64 { +func QuadbinCellToParent(cell uint64, parent_resolution uint32) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.quadbin_cell_to_parent(C.uint64_t(cell), C.uint32_t(parent_resolution)) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // QuadbinCellToChildren wraps MEOS C function quadbin_cell_to_children. -func QuadbinCellToChildren(cell uint64, children_resolution uint32, count unsafe.Pointer) unsafe.Pointer { +func QuadbinCellToChildren(cell uint64, children_resolution uint32, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.quadbin_cell_to_children(C.uint64_t(cell), C.uint32_t(children_resolution), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // QuadbinCellSibling wraps MEOS C function quadbin_cell_sibling. -func QuadbinCellSibling(cell uint64, direction string) uint64 { +func QuadbinCellSibling(cell uint64, direction string) (_r0 uint64, _err error) { _c_direction := C.CString(direction) defer C.free(unsafe.Pointer(_c_direction)) + C.meos_errno_reset() _cret := C.quadbin_cell_sibling(C.uint64_t(cell), _c_direction) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // QuadbinKRing wraps MEOS C function quadbin_k_ring. -func QuadbinKRing(cell uint64, k int, count unsafe.Pointer) unsafe.Pointer { +func QuadbinKRing(cell uint64, k int, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.quadbin_k_ring(C.uint64_t(cell), C.int(k), (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // QuadbinPointToCell wraps MEOS C function quadbin_point_to_cell. -func QuadbinPointToCell(longitude float64, latitude float64, resolution uint32) uint64 { +func QuadbinPointToCell(longitude float64, latitude float64, resolution uint32) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.quadbin_point_to_cell(C.double(longitude), C.double(latitude), C.uint32_t(resolution)) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // GeoToQuadbinCell wraps MEOS C function geo_to_quadbin_cell. -func GeoToQuadbinCell(point *Geom, resolution int32) uint64 { +func GeoToQuadbinCell(point *Geom, resolution int32) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.geo_to_quadbin_cell(point._inner, C.int32(resolution)) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // QuadbinCellToGeompoint wraps MEOS C function quadbin_cell_to_geompoint. -func QuadbinCellToGeompoint(cell uint64) *Geom { +func QuadbinCellToGeompoint(cell uint64) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.quadbin_cell_to_geompoint(C.uint64_t(cell)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // QuadbinCellToGeom wraps MEOS C function quadbin_cell_to_geom. -func QuadbinCellToGeom(cell uint64) *Geom { +func QuadbinCellToGeom(cell uint64) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.quadbin_cell_to_geom(C.uint64_t(cell)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // QuadbinToSTBOX wraps MEOS C function quadbin_to_stbox. -func QuadbinToSTBOX(cell uint64) *STBox { +func QuadbinToSTBOX(cell uint64) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.quadbin_to_stbox(C.uint64_t(cell)) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // QuadbinTimestamptzToSTBOX wraps MEOS C function quadbin_timestamptz_to_stbox. -func QuadbinTimestamptzToSTBOX(cell uint64, t int64) *STBox { +func QuadbinTimestamptzToSTBOX(cell uint64, t int64) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.quadbin_timestamptz_to_stbox(C.uint64_t(cell), C.TimestampTz(t)) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // QuadbinTstzspanToSTBOX wraps MEOS C function quadbin_tstzspan_to_stbox. -func QuadbinTstzspanToSTBOX(cell uint64, s *Span) *STBox { +func QuadbinTstzspanToSTBOX(cell uint64, s *Span) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.quadbin_tstzspan_to_stbox(C.uint64_t(cell), s._inner) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // QuadbinCellArea wraps MEOS C function quadbin_cell_area. -func QuadbinCellArea(cell uint64) float64 { +func QuadbinCellArea(cell uint64) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.quadbin_cell_area(C.uint64_t(cell)) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // QuadbinIndexToString wraps MEOS C function quadbin_index_to_string. -func QuadbinIndexToString(index uint64) string { +func QuadbinIndexToString(index uint64) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.quadbin_index_to_string(C.uint64_t(index)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // QuadbinStringToIndex wraps MEOS C function quadbin_string_to_index. -func QuadbinStringToIndex(str string) uint64 { +func QuadbinStringToIndex(str string) (_r0 uint64, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.quadbin_string_to_index(_c_str) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // QuadbinCellToQuadkey wraps MEOS C function quadbin_cell_to_quadkey. -func QuadbinCellToQuadkey(cell uint64) string { +func QuadbinCellToQuadkey(cell uint64) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.quadbin_cell_to_quadkey(C.uint64_t(cell)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // QuadbinGridDisk wraps MEOS C function quadbin_grid_disk. -func QuadbinGridDisk(origin uint64, k int) *Set { +func QuadbinGridDisk(origin uint64, k int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.quadbin_grid_disk(C.uint64_t(origin), C.int(k)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // QuadbinCellToChildrenSet wraps MEOS C function quadbin_cell_to_children_set. -func QuadbinCellToChildrenSet(origin uint64, children_resolution int) *Set { +func QuadbinCellToChildrenSet(origin uint64, children_resolution int) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.quadbin_cell_to_children_set(C.uint64_t(origin), C.int(children_resolution)) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TquadbinIn wraps MEOS C function tquadbin_in. -func TquadbinIn(str string) *Temporal { +func TquadbinIn(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tquadbin_in(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TquadbininstIn wraps MEOS C function tquadbininst_in. -func TquadbininstIn(str string) *TInstant { +func TquadbininstIn(str string) (_r0 *TInstant, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tquadbininst_in(_c_str) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TquadbinseqIn wraps MEOS C function tquadbinseq_in. -func TquadbinseqIn(str string, interp Interpolation) *TSequence { +func TquadbinseqIn(str string, interp Interpolation) (_r0 *TSequence, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tquadbinseq_in(_c_str, C.interpType(interp)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TquadbinseqsetIn wraps MEOS C function tquadbinseqset_in. -func TquadbinseqsetIn(str string) *TSequenceSet { +func TquadbinseqsetIn(str string) (_r0 *TSequenceSet, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.tquadbinseqset_in(_c_str) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TquadbinMake wraps MEOS C function tquadbin_make. -func TquadbinMake(value uint64, t int64) *Temporal { +func TquadbinMake(value uint64, t int64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tquadbin_make(C.uint64_t(value), C.TimestampTz(t)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TquadbininstMake wraps MEOS C function tquadbininst_make. -func TquadbininstMake(value uint64, t int64) *TInstant { +func TquadbininstMake(value uint64, t int64) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.tquadbininst_make(C.uint64_t(value), C.TimestampTz(t)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TquadbinseqMake wraps MEOS C function tquadbinseq_make. -func TquadbinseqMake(values unsafe.Pointer, times unsafe.Pointer, count int, lower_inc bool, upper_inc bool) *TSequence { +func TquadbinseqMake(values unsafe.Pointer, times unsafe.Pointer, count int, lower_inc bool, upper_inc bool) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.tquadbinseq_make((*C.uint64_t)(unsafe.Pointer(values)), (*C.TimestampTz)(unsafe.Pointer(times)), C.int(count), C.bool(lower_inc), C.bool(upper_inc)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TquadbinseqsetMake wraps MEOS C function tquadbinseqset_make. -func TquadbinseqsetMake(sequences unsafe.Pointer, count int) *TSequenceSet { +func TquadbinseqsetMake(sequences unsafe.Pointer, count int) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.tquadbinseqset_make((**C.TSequence)(unsafe.Pointer(sequences)), C.int(count)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TquadbinStartValue wraps MEOS C function tquadbin_start_value. -func TquadbinStartValue(temp *Temporal) uint64 { +func TquadbinStartValue(temp *Temporal) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.tquadbin_start_value(temp._inner) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // TquadbinEndValue wraps MEOS C function tquadbin_end_value. -func TquadbinEndValue(temp *Temporal) uint64 { +func TquadbinEndValue(temp *Temporal) (_r0 uint64, _err error) { + C.meos_errno_reset() _cret := C.tquadbin_end_value(temp._inner) - return uint64(_cret) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil } // TquadbinValueN wraps MEOS C function tquadbin_value_n. -func TquadbinValueN(temp *Temporal, n int) (bool, uint64) { +func TquadbinValueN(temp *Temporal, n int) (_r0 bool, _r1 uint64, _err error) { var _out_result C.uint64_t + C.meos_errno_reset() _cret := C.tquadbin_value_n(temp._inner, C.int(n), &_out_result) - return bool(_cret), uint64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), uint64(_out_result), nil } // TquadbinValues wraps MEOS C function tquadbin_values. -func TquadbinValues(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TquadbinValues(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.tquadbin_values(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TquadbinValueAtTimestamptz wraps MEOS C function tquadbin_value_at_timestamptz. -func TquadbinValueAtTimestamptz(temp *Temporal, t int64, strict bool) (bool, uint64) { +func TquadbinValueAtTimestamptz(temp *Temporal, t int64, strict bool) (_r0 bool, _r1 uint64, _err error) { var _out_result C.uint64_t + C.meos_errno_reset() _cret := C.tquadbin_value_at_timestamptz(temp._inner, C.TimestampTz(t), C.bool(strict), &_out_result) - return bool(_cret), uint64(_out_result) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), uint64(_out_result), nil } // TbigintToTquadbin wraps MEOS C function tbigint_to_tquadbin. -func TbigintToTquadbin(temp *Temporal) *Temporal { +func TbigintToTquadbin(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tbigint_to_tquadbin(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TquadbinToTbigint wraps MEOS C function tquadbin_to_tbigint. -func TquadbinToTbigint(temp *Temporal) *Temporal { +func TquadbinToTbigint(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tquadbin_to_tbigint(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // EverEqQuadbinTquadbin wraps MEOS C function ever_eq_quadbin_tquadbin. -func EverEqQuadbinTquadbin(cell uint64, temp *Temporal) int { +func EverEqQuadbinTquadbin(cell uint64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_quadbin_tquadbin(C.uint64_t(cell), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTquadbinQuadbin wraps MEOS C function ever_eq_tquadbin_quadbin. -func EverEqTquadbinQuadbin(temp *Temporal, cell uint64) int { +func EverEqTquadbinQuadbin(temp *Temporal, cell uint64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_tquadbin_quadbin(temp._inner, C.uint64_t(cell)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeQuadbinTquadbin wraps MEOS C function ever_ne_quadbin_tquadbin. -func EverNeQuadbinTquadbin(cell uint64, temp *Temporal) int { +func EverNeQuadbinTquadbin(cell uint64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_quadbin_tquadbin(C.uint64_t(cell), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTquadbinQuadbin wraps MEOS C function ever_ne_tquadbin_quadbin. -func EverNeTquadbinQuadbin(temp *Temporal, cell uint64) int { +func EverNeTquadbinQuadbin(temp *Temporal, cell uint64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_tquadbin_quadbin(temp._inner, C.uint64_t(cell)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqQuadbinTquadbin wraps MEOS C function always_eq_quadbin_tquadbin. -func AlwaysEqQuadbinTquadbin(cell uint64, temp *Temporal) int { +func AlwaysEqQuadbinTquadbin(cell uint64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_quadbin_tquadbin(C.uint64_t(cell), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTquadbinQuadbin wraps MEOS C function always_eq_tquadbin_quadbin. -func AlwaysEqTquadbinQuadbin(temp *Temporal, cell uint64) int { +func AlwaysEqTquadbinQuadbin(temp *Temporal, cell uint64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_tquadbin_quadbin(temp._inner, C.uint64_t(cell)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeQuadbinTquadbin wraps MEOS C function always_ne_quadbin_tquadbin. -func AlwaysNeQuadbinTquadbin(cell uint64, temp *Temporal) int { +func AlwaysNeQuadbinTquadbin(cell uint64, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_quadbin_tquadbin(C.uint64_t(cell), temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTquadbinQuadbin wraps MEOS C function always_ne_tquadbin_quadbin. -func AlwaysNeTquadbinQuadbin(temp *Temporal, cell uint64) int { +func AlwaysNeTquadbinQuadbin(temp *Temporal, cell uint64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_tquadbin_quadbin(temp._inner, C.uint64_t(cell)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTquadbinTquadbin wraps MEOS C function ever_eq_tquadbin_tquadbin. -func EverEqTquadbinTquadbin(temp1 *Temporal, temp2 *Temporal) int { +func EverEqTquadbinTquadbin(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_tquadbin_tquadbin(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTquadbinTquadbin wraps MEOS C function ever_ne_tquadbin_tquadbin. -func EverNeTquadbinTquadbin(temp1 *Temporal, temp2 *Temporal) int { +func EverNeTquadbinTquadbin(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_tquadbin_tquadbin(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTquadbinTquadbin wraps MEOS C function always_eq_tquadbin_tquadbin. -func AlwaysEqTquadbinTquadbin(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysEqTquadbinTquadbin(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_tquadbin_tquadbin(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTquadbinTquadbin wraps MEOS C function always_ne_tquadbin_tquadbin. -func AlwaysNeTquadbinTquadbin(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysNeTquadbinTquadbin(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_tquadbin_tquadbin(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TeqQuadbinTquadbin wraps MEOS C function teq_quadbin_tquadbin. -func TeqQuadbinTquadbin(cell uint64, temp *Temporal) *Temporal { +func TeqQuadbinTquadbin(cell uint64, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_quadbin_tquadbin(C.uint64_t(cell), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TeqTquadbinQuadbin wraps MEOS C function teq_tquadbin_quadbin. -func TeqTquadbinQuadbin(temp *Temporal, cell uint64) *Temporal { +func TeqTquadbinQuadbin(temp *Temporal, cell uint64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_tquadbin_quadbin(temp._inner, C.uint64_t(cell)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TeqTquadbinTquadbin wraps MEOS C function teq_tquadbin_tquadbin. -func TeqTquadbinTquadbin(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TeqTquadbinTquadbin(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_tquadbin_tquadbin(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneQuadbinTquadbin wraps MEOS C function tne_quadbin_tquadbin. -func TneQuadbinTquadbin(cell uint64, temp *Temporal) *Temporal { +func TneQuadbinTquadbin(cell uint64, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_quadbin_tquadbin(C.uint64_t(cell), temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneTquadbinQuadbin wraps MEOS C function tne_tquadbin_quadbin. -func TneTquadbinQuadbin(temp *Temporal, cell uint64) *Temporal { +func TneTquadbinQuadbin(temp *Temporal, cell uint64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_tquadbin_quadbin(temp._inner, C.uint64_t(cell)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneTquadbinTquadbin wraps MEOS C function tne_tquadbin_tquadbin. -func TneTquadbinTquadbin(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TneTquadbinTquadbin(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_tquadbin_tquadbin(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TquadbinCellToQuadkey wraps MEOS C function tquadbin_cell_to_quadkey. -func TquadbinCellToQuadkey(temp *Temporal) *Temporal { +func TquadbinCellToQuadkey(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tquadbin_cell_to_quadkey(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } diff --git a/functions/meos_meos_rgeo.go b/functions/meos_meos_rgeo.go index 7626c0b..ee9a168 100644 --- a/functions/meos_meos_rgeo.go +++ b/functions/meos_meos_rgeo.go @@ -86,920 +86,1440 @@ import ( var _ = unsafe.Pointer(nil) // TrgeometryIn wraps MEOS C function trgeometry_in. -func TrgeometryIn(str string) *Temporal { +func TrgeometryIn(str string) (_r0 *Temporal, _err error) { _c_str := C.CString(str) defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() _cret := C.trgeometry_in(_c_str) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryFromMFJSON wraps MEOS C function trgeometry_from_mfjson. -func TrgeometryFromMFJSON(mfjson string) *Temporal { +func TrgeometryFromMFJSON(mfjson string) (_r0 *Temporal, _err error) { _c_mfjson := C.CString(mfjson) defer C.free(unsafe.Pointer(_c_mfjson)) + C.meos_errno_reset() _cret := C.trgeometry_from_mfjson(_c_mfjson) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryOut wraps MEOS C function trgeometry_out. -func TrgeometryOut(temp *Temporal) string { +func TrgeometryOut(temp *Temporal) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_out(temp._inner) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TrgeometryAsText wraps MEOS C function trgeometry_as_text. -func TrgeometryAsText(temp *Temporal, maxdd int) string { +func TrgeometryAsText(temp *Temporal, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_as_text(temp._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TrgeometryAsEWKT wraps MEOS C function trgeometry_as_ewkt. -func TrgeometryAsEWKT(temp *Temporal, maxdd int) string { +func TrgeometryAsEWKT(temp *Temporal, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_as_ewkt(temp._inner, C.int(maxdd)) - return C.GoString(_cret) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil } // TrgeometryinstMake wraps MEOS C function trgeometryinst_make. -func TrgeometryinstMake(geom *Geom, pose *Pose, t int64) *TInstant { +func TrgeometryinstMake(geom *Geom, pose *Pose, t int64) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.trgeometryinst_make(geom._inner, pose._inner, C.TimestampTz(t)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // 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 { +func TrgeometryseqMake(geom *Geom, instants unsafe.Pointer, count int, lower_inc bool, upper_inc bool, interp Interpolation, normalize bool) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _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} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TrgeometryseqsetMake wraps MEOS C function trgeometryseqset_make. -func TrgeometryseqsetMake(geom *Geom, sequences unsafe.Pointer, count int, normalize bool) *TSequenceSet { +func TrgeometryseqsetMake(geom *Geom, sequences unsafe.Pointer, count int, normalize bool) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _cret := C.trgeometryseqset_make(geom._inner, (**C.TSequence)(unsafe.Pointer(sequences)), C.int(count), C.bool(normalize)) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TrgeometryseqsetMakeGaps wraps MEOS C function trgeometryseqset_make_gaps. -func TrgeometryseqsetMakeGaps(geom *Geom, instants unsafe.Pointer, count int, interp Interpolation, maxt *Interval, maxdist float64) *TSequenceSet { +func TrgeometryseqsetMakeGaps(geom *Geom, instants unsafe.Pointer, count int, interp Interpolation, maxt *Interval, maxdist float64) (_r0 *TSequenceSet, _err error) { + C.meos_errno_reset() _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} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // GeometryTposeToTrgeometry wraps MEOS C function geometry_tpose_to_trgeometry. -func GeometryTposeToTrgeometry(gs *Geom, temp *Temporal) *Temporal { +func GeometryTposeToTrgeometry(gs *Geom, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.geometry_tpose_to_trgeometry(gs._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryToTpose wraps MEOS C function trgeometry_to_tpose. -func TrgeometryToTpose(temp *Temporal) *Temporal { +func TrgeometryToTpose(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_to_tpose(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryToTgeompoint wraps MEOS C function trgeometry_to_tgeompoint. -func TrgeometryToTgeompoint(temp *Temporal) *Temporal { +func TrgeometryToTgeompoint(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_to_tgeompoint(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryToTgeometry wraps MEOS C function trgeometry_to_tgeometry. -func TrgeometryToTgeometry(temp *Temporal) *Temporal { +func TrgeometryToTgeometry(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_to_tgeometry(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryEndInstant wraps MEOS C function trgeometry_end_instant. -func TrgeometryEndInstant(temp *Temporal) *TInstant { +func TrgeometryEndInstant(temp *Temporal) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_end_instant(temp._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TrgeometryEndSequence wraps MEOS C function trgeometry_end_sequence. -func TrgeometryEndSequence(temp *Temporal) *TSequence { +func TrgeometryEndSequence(temp *Temporal) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_end_sequence(temp._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TrgeometryEndValue wraps MEOS C function trgeometry_end_value. -func TrgeometryEndValue(temp *Temporal) *Geom { +func TrgeometryEndValue(temp *Temporal) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_end_value(temp._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // TrgeometryGeom wraps MEOS C function trgeometry_geom. -func TrgeometryGeom(temp *Temporal) *Geom { +func TrgeometryGeom(temp *Temporal) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_geom(temp._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // TrgeometryInstantN wraps MEOS C function trgeometry_instant_n. -func TrgeometryInstantN(temp *Temporal, n int) *TInstant { +func TrgeometryInstantN(temp *Temporal, n int) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_instant_n(temp._inner, C.int(n)) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TrgeometryInstants wraps MEOS C function trgeometry_instants. -func TrgeometryInstants(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TrgeometryInstants(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_instants(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TrgeometryPoints wraps MEOS C function trgeometry_points. -func TrgeometryPoints(temp *Temporal) *Set { +func TrgeometryPoints(temp *Temporal) (_r0 *Set, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_points(temp._inner) - return &Set{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil } // TrgeometryRotation wraps MEOS C function trgeometry_rotation. -func TrgeometryRotation(temp *Temporal) *Temporal { +func TrgeometryRotation(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_rotation(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometrySegments wraps MEOS C function trgeometry_segments. -func TrgeometrySegments(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TrgeometrySegments(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_segments(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TrgeometrySequenceN wraps MEOS C function trgeometry_sequence_n. -func TrgeometrySequenceN(temp *Temporal, i int) *TSequence { +func TrgeometrySequenceN(temp *Temporal, i int) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_sequence_n(temp._inner, C.int(i)) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TrgeometrySequences wraps MEOS C function trgeometry_sequences. -func TrgeometrySequences(temp *Temporal, count unsafe.Pointer) unsafe.Pointer { +func TrgeometrySequences(temp *Temporal, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_sequences(temp._inner, (*C.int)(unsafe.Pointer(count))) - return unsafe.Pointer(_cret) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil } // TrgeometryStartInstant wraps MEOS C function trgeometry_start_instant. -func TrgeometryStartInstant(temp *Temporal) *TInstant { +func TrgeometryStartInstant(temp *Temporal) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_start_instant(temp._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TrgeometryStartSequence wraps MEOS C function trgeometry_start_sequence. -func TrgeometryStartSequence(temp *Temporal) *TSequence { +func TrgeometryStartSequence(temp *Temporal) (_r0 *TSequence, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_start_sequence(temp._inner) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TrgeometryStartValue wraps MEOS C function trgeometry_start_value. -func TrgeometryStartValue(temp *Temporal) *Geom { +func TrgeometryStartValue(temp *Temporal) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_start_value(temp._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // TrgeometryValueN wraps MEOS C function trgeometry_value_n. -func TrgeometryValueN(temp *Temporal, n int) (bool, *Geom) { +func TrgeometryValueN(temp *Temporal, n int) (_r0 bool, _r1 *Geom, _err error) { var _out_result *C.GSERIALIZED + C.meos_errno_reset() _cret := C.trgeometry_value_n(temp._inner, C.int(n), &_out_result) - return bool(_cret), &Geom{_inner: _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) *Geom { +func TrgeometryTraversedArea(temp *Temporal, unary_union bool) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_traversed_area(temp._inner, C.bool(unary_union)) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // TrgeometryCentroid wraps MEOS C function trgeometry_centroid. -func TrgeometryCentroid(temp *Temporal) *Temporal { +func TrgeometryCentroid(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_centroid(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryConvexHull wraps MEOS C function trgeometry_convex_hull. -func TrgeometryConvexHull(temp *Temporal) *Geom { +func TrgeometryConvexHull(temp *Temporal) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_convex_hull(temp._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // TrgeometryBodyPointTrajectory wraps MEOS C function trgeometry_body_point_trajectory. -func TrgeometryBodyPointTrajectory(temp *Temporal, gs *Geom) *Temporal { +func TrgeometryBodyPointTrajectory(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_body_point_trajectory(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometrySpaceBoxes wraps MEOS C function trgeometry_space_boxes. -func TrgeometrySpaceBoxes(temp *Temporal, xsize float64, ysize float64, zsize float64, sorigin *Geom, bitmatrix bool, border_inc bool, count unsafe.Pointer) *STBox { +func TrgeometrySpaceBoxes(temp *Temporal, xsize float64, ysize float64, zsize float64, sorigin *Geom, bitmatrix bool, border_inc bool, count unsafe.Pointer) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_space_boxes(temp._inner, C.double(xsize), C.double(ysize), C.double(zsize), sorigin._inner, C.bool(bitmatrix), C.bool(border_inc), (*C.int)(unsafe.Pointer(count))) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // TrgeometrySpaceTimeBoxes wraps MEOS C function trgeometry_space_time_boxes. -func TrgeometrySpaceTimeBoxes(temp *Temporal, xsize float64, ysize float64, zsize float64, duration *Interval, sorigin *Geom, torigin int64, bitmatrix bool, border_inc bool, count unsafe.Pointer) *STBox { +func TrgeometrySpaceTimeBoxes(temp *Temporal, xsize float64, ysize float64, zsize float64, duration *Interval, sorigin *Geom, torigin int64, bitmatrix bool, border_inc bool, count unsafe.Pointer) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_space_time_boxes(temp._inner, C.double(xsize), C.double(ysize), C.double(zsize), duration._inner, sorigin._inner, C.TimestampTz(torigin), C.bool(bitmatrix), C.bool(border_inc), (*C.int)(unsafe.Pointer(count))) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // TrgeometryStboxes wraps MEOS C function trgeometry_stboxes. -func TrgeometryStboxes(temp *Temporal, count unsafe.Pointer) *STBox { +func TrgeometryStboxes(temp *Temporal, count unsafe.Pointer) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_stboxes(temp._inner, (*C.int)(unsafe.Pointer(count))) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // TrgeometrySplitNStboxes wraps MEOS C function trgeometry_split_n_stboxes. -func TrgeometrySplitNStboxes(temp *Temporal, box_count int, count unsafe.Pointer) *STBox { +func TrgeometrySplitNStboxes(temp *Temporal, box_count int, count unsafe.Pointer) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_split_n_stboxes(temp._inner, C.int(box_count), (*C.int)(unsafe.Pointer(count))) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // TrgeometrySplitEachNStboxes wraps MEOS C function trgeometry_split_each_n_stboxes. -func TrgeometrySplitEachNStboxes(temp *Temporal, elem_count int, count unsafe.Pointer) *STBox { +func TrgeometrySplitEachNStboxes(temp *Temporal, elem_count int, count unsafe.Pointer) (_r0 *STBox, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_split_each_n_stboxes(temp._inner, C.int(elem_count), (*C.int)(unsafe.Pointer(count))) - return &STBox{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil } // TrgeometryHausdorffDistance wraps MEOS C function trgeometry_hausdorff_distance. -func TrgeometryHausdorffDistance(temp1 *Temporal, temp2 *Temporal) float64 { +func TrgeometryHausdorffDistance(temp1 *Temporal, temp2 *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_hausdorff_distance(temp1._inner, temp2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TrgeometryFrechetDistance wraps MEOS C function trgeometry_frechet_distance. -func TrgeometryFrechetDistance(temp1 *Temporal, temp2 *Temporal) float64 { +func TrgeometryFrechetDistance(temp1 *Temporal, temp2 *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_frechet_distance(temp1._inner, temp2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TrgeometryDyntimewarpDistance wraps MEOS C function trgeometry_dyntimewarp_distance. -func TrgeometryDyntimewarpDistance(temp1 *Temporal, temp2 *Temporal) float64 { +func TrgeometryDyntimewarpDistance(temp1 *Temporal, temp2 *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_dyntimewarp_distance(temp1._inner, temp2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TrgeometryFrechetPath wraps MEOS C function trgeometry_frechet_path. -func TrgeometryFrechetPath(temp1 *Temporal, temp2 *Temporal, count unsafe.Pointer) *Match { +func TrgeometryFrechetPath(temp1 *Temporal, temp2 *Temporal, count unsafe.Pointer) (_r0 *Match, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_frechet_path(temp1._inner, temp2._inner, (*C.int)(unsafe.Pointer(count))) - return &Match{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Match{_inner: _cret}, nil } // TrgeometryDyntimewarpPath wraps MEOS C function trgeometry_dyntimewarp_path. -func TrgeometryDyntimewarpPath(temp1 *Temporal, temp2 *Temporal, count unsafe.Pointer) *Match { +func TrgeometryDyntimewarpPath(temp1 *Temporal, temp2 *Temporal, count unsafe.Pointer) (_r0 *Match, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_dyntimewarp_path(temp1._inner, temp2._inner, (*C.int)(unsafe.Pointer(count))) - return &Match{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Match{_inner: _cret}, nil } // TrgeometryLength wraps MEOS C function trgeometry_length. -func TrgeometryLength(temp *Temporal) float64 { +func TrgeometryLength(temp *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_length(temp._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // TrgeometryCumulativeLength wraps MEOS C function trgeometry_cumulative_length. -func TrgeometryCumulativeLength(temp *Temporal) *Temporal { +func TrgeometryCumulativeLength(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_cumulative_length(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometrySpeed wraps MEOS C function trgeometry_speed. -func TrgeometrySpeed(temp *Temporal) *Temporal { +func TrgeometrySpeed(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_speed(temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryTwcentroid wraps MEOS C function trgeometry_twcentroid. -func TrgeometryTwcentroid(temp *Temporal) *Geom { +func TrgeometryTwcentroid(temp *Temporal) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_twcentroid(temp._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // TrgeometryAppendTinstant wraps MEOS C function trgeometry_append_tinstant. -func TrgeometryAppendTinstant(temp *Temporal, inst *TInstant, interp Interpolation, maxdist float64, maxt *Interval, expand bool) *Temporal { +func TrgeometryAppendTinstant(temp *Temporal, inst *TInstant, interp Interpolation, maxdist float64, maxt *Interval, expand bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_append_tinstant(temp._inner, inst._inner, C.interpType(interp), C.double(maxdist), maxt._inner, C.bool(expand)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryAppendTsequence wraps MEOS C function trgeometry_append_tsequence. -func TrgeometryAppendTsequence(temp *Temporal, seq *TSequence, expand bool) *Temporal { +func TrgeometryAppendTsequence(temp *Temporal, seq *TSequence, expand bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_append_tsequence(temp._inner, seq._inner, C.bool(expand)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryDeleteTimestamptz wraps MEOS C function trgeometry_delete_timestamptz. -func TrgeometryDeleteTimestamptz(temp *Temporal, t int64, connect bool) *Temporal { +func TrgeometryDeleteTimestamptz(temp *Temporal, t int64, connect bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_delete_timestamptz(temp._inner, C.TimestampTz(t), C.bool(connect)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryDeleteTstzset wraps MEOS C function trgeometry_delete_tstzset. -func TrgeometryDeleteTstzset(temp *Temporal, s *Set, connect bool) *Temporal { +func TrgeometryDeleteTstzset(temp *Temporal, s *Set, connect bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_delete_tstzset(temp._inner, s._inner, C.bool(connect)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryDeleteTstzspan wraps MEOS C function trgeometry_delete_tstzspan. -func TrgeometryDeleteTstzspan(temp *Temporal, s *Span, connect bool) *Temporal { +func TrgeometryDeleteTstzspan(temp *Temporal, s *Span, connect bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_delete_tstzspan(temp._inner, s._inner, C.bool(connect)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryDeleteTstzspanset wraps MEOS C function trgeometry_delete_tstzspanset. -func TrgeometryDeleteTstzspanset(temp *Temporal, ss *SpanSet, connect bool) *Temporal { +func TrgeometryDeleteTstzspanset(temp *Temporal, ss *SpanSet, connect bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_delete_tstzspanset(temp._inner, ss._inner, C.bool(connect)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryRound wraps MEOS C function trgeometry_round. -func TrgeometryRound(temp *Temporal, maxdd int) *Temporal { +func TrgeometryRound(temp *Temporal, maxdd int) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_round(temp._inner, C.int(maxdd)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometrySetInterp wraps MEOS C function trgeometry_set_interp. -func TrgeometrySetInterp(temp *Temporal, interp Interpolation) *Temporal { +func TrgeometrySetInterp(temp *Temporal, interp Interpolation) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_set_interp(temp._inner, C.interpType(interp)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryAsTinstant wraps MEOS C function trgeometry_as_tinstant. -func TrgeometryAsTinstant(temp *Temporal) *TInstant { +func TrgeometryAsTinstant(temp *Temporal) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_as_tinstant(temp._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // TrgeometryAsTsequence wraps MEOS C function trgeometry_as_tsequence. -func TrgeometryAsTsequence(temp *Temporal, interp_str string) *TSequence { +func TrgeometryAsTsequence(temp *Temporal, interp_str string) (_r0 *TSequence, _err error) { _c_interp_str := C.CString(interp_str) defer C.free(unsafe.Pointer(_c_interp_str)) + C.meos_errno_reset() _cret := C.trgeometry_as_tsequence(temp._inner, _c_interp_str) - return &TSequence{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequence{_inner: _cret}, nil } // TrgeometryAsTsequenceset wraps MEOS C function trgeometry_as_tsequenceset. -func TrgeometryAsTsequenceset(temp *Temporal, interp_str string) *TSequenceSet { +func TrgeometryAsTsequenceset(temp *Temporal, interp_str string) (_r0 *TSequenceSet, _err error) { _c_interp_str := C.CString(interp_str) defer C.free(unsafe.Pointer(_c_interp_str)) + C.meos_errno_reset() _cret := C.trgeometry_as_tsequenceset(temp._inner, _c_interp_str) - return &TSequenceSet{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TSequenceSet{_inner: _cret}, nil } // TrgeometryAfterTimestamptz wraps MEOS C function trgeometry_after_timestamptz. -func TrgeometryAfterTimestamptz(temp *Temporal, t int64, strict bool) *Temporal { +func TrgeometryAfterTimestamptz(temp *Temporal, t int64, strict bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_after_timestamptz(temp._inner, C.TimestampTz(t), C.bool(strict)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryBeforeTimestamptz wraps MEOS C function trgeometry_before_timestamptz. -func TrgeometryBeforeTimestamptz(temp *Temporal, t int64, strict bool) *Temporal { +func TrgeometryBeforeTimestamptz(temp *Temporal, t int64, strict bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_before_timestamptz(temp._inner, C.TimestampTz(t), C.bool(strict)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryRestrictValues wraps MEOS C function trgeometry_restrict_values. -func TrgeometryRestrictValues(temp *Temporal, s *Set, atfunc bool) *Temporal { +func TrgeometryRestrictValues(temp *Temporal, s *Set, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_restrict_values(temp._inner, s._inner, C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryRestrictTimestamptz wraps MEOS C function trgeometry_restrict_timestamptz. -func TrgeometryRestrictTimestamptz(temp *Temporal, t int64, atfunc bool) *Temporal { +func TrgeometryRestrictTimestamptz(temp *Temporal, t int64, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_restrict_timestamptz(temp._inner, C.TimestampTz(t), C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryRestrictTstzset wraps MEOS C function trgeometry_restrict_tstzset. -func TrgeometryRestrictTstzset(temp *Temporal, s *Set, atfunc bool) *Temporal { +func TrgeometryRestrictTstzset(temp *Temporal, s *Set, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_restrict_tstzset(temp._inner, s._inner, C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryRestrictTstzspan wraps MEOS C function trgeometry_restrict_tstzspan. -func TrgeometryRestrictTstzspan(temp *Temporal, s *Span, atfunc bool) *Temporal { +func TrgeometryRestrictTstzspan(temp *Temporal, s *Span, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_restrict_tstzspan(temp._inner, s._inner, C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryRestrictTstzspanset wraps MEOS C function trgeometry_restrict_tstzspanset. -func TrgeometryRestrictTstzspanset(temp *Temporal, ss *SpanSet, atfunc bool) *Temporal { +func TrgeometryRestrictTstzspanset(temp *Temporal, ss *SpanSet, atfunc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_restrict_tstzspanset(temp._inner, ss._inner, C.bool(atfunc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryAtGeom wraps MEOS C function trgeometry_at_geom. -func TrgeometryAtGeom(temp *Temporal, gs *Geom) *Temporal { +func TrgeometryAtGeom(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_at_geom(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryMinusGeom wraps MEOS C function trgeometry_minus_geom. -func TrgeometryMinusGeom(temp *Temporal, gs *Geom) *Temporal { +func TrgeometryMinusGeom(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_minus_geom(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryAtSTBOX wraps MEOS C function trgeometry_at_stbox. -func TrgeometryAtSTBOX(temp *Temporal, box *STBox, border_inc bool) *Temporal { +func TrgeometryAtSTBOX(temp *Temporal, box *STBox, border_inc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_at_stbox(temp._inner, box._inner, C.bool(border_inc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryMinusSTBOX wraps MEOS C function trgeometry_minus_stbox. -func TrgeometryMinusSTBOX(temp *Temporal, box *STBox, border_inc bool) *Temporal { +func TrgeometryMinusSTBOX(temp *Temporal, box *STBox, border_inc bool) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_minus_stbox(temp._inner, box._inner, C.bool(border_inc)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryAtValue wraps MEOS C function trgeometry_at_value. -func TrgeometryAtValue(temp *Temporal, pose *Pose) *Temporal { +func TrgeometryAtValue(temp *Temporal, pose *Pose) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_at_value(temp._inner, pose._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryMinusValue wraps MEOS C function trgeometry_minus_value. -func TrgeometryMinusValue(temp *Temporal, pose *Pose) *Temporal { +func TrgeometryMinusValue(temp *Temporal, pose *Pose) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_minus_value(temp._inner, pose._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryAtValues wraps MEOS C function trgeometry_at_values. -func TrgeometryAtValues(temp *Temporal, s *Set) *Temporal { +func TrgeometryAtValues(temp *Temporal, s *Set) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_at_values(temp._inner, s._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryMinusValues wraps MEOS C function trgeometry_minus_values. -func TrgeometryMinusValues(temp *Temporal, s *Set) *Temporal { +func TrgeometryMinusValues(temp *Temporal, s *Set) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_minus_values(temp._inner, s._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryAtTimestamptz wraps MEOS C function trgeometry_at_timestamptz. -func TrgeometryAtTimestamptz(temp *Temporal, t int64) *Temporal { +func TrgeometryAtTimestamptz(temp *Temporal, t int64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_at_timestamptz(temp._inner, C.TimestampTz(t)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryMinusTimestamptz wraps MEOS C function trgeometry_minus_timestamptz. -func TrgeometryMinusTimestamptz(temp *Temporal, t int64) *Temporal { +func TrgeometryMinusTimestamptz(temp *Temporal, t int64) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_minus_timestamptz(temp._inner, C.TimestampTz(t)) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryAtTstzset wraps MEOS C function trgeometry_at_tstzset. -func TrgeometryAtTstzset(temp *Temporal, s *Set) *Temporal { +func TrgeometryAtTstzset(temp *Temporal, s *Set) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_at_tstzset(temp._inner, s._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryMinusTstzset wraps MEOS C function trgeometry_minus_tstzset. -func TrgeometryMinusTstzset(temp *Temporal, s *Set) *Temporal { +func TrgeometryMinusTstzset(temp *Temporal, s *Set) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_minus_tstzset(temp._inner, s._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryAtTstzspan wraps MEOS C function trgeometry_at_tstzspan. -func TrgeometryAtTstzspan(temp *Temporal, s *Span) *Temporal { +func TrgeometryAtTstzspan(temp *Temporal, s *Span) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_at_tstzspan(temp._inner, s._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryMinusTstzspan wraps MEOS C function trgeometry_minus_tstzspan. -func TrgeometryMinusTstzspan(temp *Temporal, s *Span) *Temporal { +func TrgeometryMinusTstzspan(temp *Temporal, s *Span) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_minus_tstzspan(temp._inner, s._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryAtTstzspanset wraps MEOS C function trgeometry_at_tstzspanset. -func TrgeometryAtTstzspanset(temp *Temporal, ss *SpanSet) *Temporal { +func TrgeometryAtTstzspanset(temp *Temporal, ss *SpanSet) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_at_tstzspanset(temp._inner, ss._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TrgeometryMinusTstzspanset wraps MEOS C function trgeometry_minus_tstzspanset. -func TrgeometryMinusTstzspanset(temp *Temporal, ss *SpanSet) *Temporal { +func TrgeometryMinusTstzspanset(temp *Temporal, ss *SpanSet) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.trgeometry_minus_tstzspanset(temp._inner, ss._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdistanceTrgeometryGeo wraps MEOS C function tdistance_trgeometry_geo. -func TdistanceTrgeometryGeo(temp *Temporal, gs *Geom) *Temporal { +func TdistanceTrgeometryGeo(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdistance_trgeometry_geo(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdistanceTrgeometryTpoint wraps MEOS C function tdistance_trgeometry_tpoint. -func TdistanceTrgeometryTpoint(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TdistanceTrgeometryTpoint(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdistance_trgeometry_tpoint(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TdistanceTrgeometryTrgeometry wraps MEOS C function tdistance_trgeometry_trgeometry. -func TdistanceTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) *Temporal { +func TdistanceTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tdistance_trgeometry_trgeometry(temp1._inner, temp2._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // NadSTBOXTrgeometry wraps MEOS C function nad_stbox_trgeometry. -func NadSTBOXTrgeometry(box *STBox, temp *Temporal) float64 { +func NadSTBOXTrgeometry(box *STBox, temp *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_stbox_trgeometry(box._inner, temp._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NadTrgeometryGeo wraps MEOS C function nad_trgeometry_geo. -func NadTrgeometryGeo(temp *Temporal, gs *Geom) float64 { +func NadTrgeometryGeo(temp *Temporal, gs *Geom) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_trgeometry_geo(temp._inner, gs._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NadTrgeometrySTBOX wraps MEOS C function nad_trgeometry_stbox. -func NadTrgeometrySTBOX(temp *Temporal, box *STBox) float64 { +func NadTrgeometrySTBOX(temp *Temporal, box *STBox) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_trgeometry_stbox(temp._inner, box._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NadTrgeometryTpoint wraps MEOS C function nad_trgeometry_tpoint. -func NadTrgeometryTpoint(temp1 *Temporal, temp2 *Temporal) float64 { +func NadTrgeometryTpoint(temp1 *Temporal, temp2 *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_trgeometry_tpoint(temp1._inner, temp2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NadTrgeometryTrgeometry wraps MEOS C function nad_trgeometry_trgeometry. -func NadTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) float64 { +func NadTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) (_r0 float64, _err error) { + C.meos_errno_reset() _cret := C.nad_trgeometry_trgeometry(temp1._inner, temp2._inner) - return float64(_cret) + if _err = meosError(); _err != nil { + return + } + return float64(_cret), nil } // NaiTrgeometryGeo wraps MEOS C function nai_trgeometry_geo. -func NaiTrgeometryGeo(temp *Temporal, gs *Geom) *TInstant { +func NaiTrgeometryGeo(temp *Temporal, gs *Geom) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.nai_trgeometry_geo(temp._inner, gs._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // NaiTrgeometryTpoint wraps MEOS C function nai_trgeometry_tpoint. -func NaiTrgeometryTpoint(temp1 *Temporal, temp2 *Temporal) *TInstant { +func NaiTrgeometryTpoint(temp1 *Temporal, temp2 *Temporal) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.nai_trgeometry_tpoint(temp1._inner, temp2._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // NaiTrgeometryTrgeometry wraps MEOS C function nai_trgeometry_trgeometry. -func NaiTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) *TInstant { +func NaiTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) (_r0 *TInstant, _err error) { + C.meos_errno_reset() _cret := C.nai_trgeometry_trgeometry(temp1._inner, temp2._inner) - return &TInstant{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &TInstant{_inner: _cret}, nil } // ShortestlineTrgeometryGeo wraps MEOS C function shortestline_trgeometry_geo. -func ShortestlineTrgeometryGeo(temp *Temporal, gs *Geom) *Geom { +func ShortestlineTrgeometryGeo(temp *Temporal, gs *Geom) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.shortestline_trgeometry_geo(temp._inner, gs._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // ShortestlineTrgeometryTpoint wraps MEOS C function shortestline_trgeometry_tpoint. -func ShortestlineTrgeometryTpoint(temp1 *Temporal, temp2 *Temporal) *Geom { +func ShortestlineTrgeometryTpoint(temp1 *Temporal, temp2 *Temporal) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.shortestline_trgeometry_tpoint(temp1._inner, temp2._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // ShortestlineTrgeometryTrgeometry wraps MEOS C function shortestline_trgeometry_trgeometry. -func ShortestlineTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) *Geom { +func ShortestlineTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) (_r0 *Geom, _err error) { + C.meos_errno_reset() _cret := C.shortestline_trgeometry_trgeometry(temp1._inner, temp2._inner) - return &Geom{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil } // AlwaysEqGeoTrgeometry wraps MEOS C function always_eq_geo_trgeometry. -func AlwaysEqGeoTrgeometry(gs *Geom, temp *Temporal) int { +func AlwaysEqGeoTrgeometry(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_geo_trgeometry(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTrgeometryGeo wraps MEOS C function always_eq_trgeometry_geo. -func AlwaysEqTrgeometryGeo(temp *Temporal, gs *Geom) int { +func AlwaysEqTrgeometryGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_trgeometry_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysEqTrgeometryTrgeometry wraps MEOS C function always_eq_trgeometry_trgeometry. -func AlwaysEqTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysEqTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_eq_trgeometry_trgeometry(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeGeoTrgeometry wraps MEOS C function always_ne_geo_trgeometry. -func AlwaysNeGeoTrgeometry(gs *Geom, temp *Temporal) int { +func AlwaysNeGeoTrgeometry(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_geo_trgeometry(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTrgeometryGeo wraps MEOS C function always_ne_trgeometry_geo. -func AlwaysNeTrgeometryGeo(temp *Temporal, gs *Geom) int { +func AlwaysNeTrgeometryGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_trgeometry_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AlwaysNeTrgeometryTrgeometry wraps MEOS C function always_ne_trgeometry_trgeometry. -func AlwaysNeTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) int { +func AlwaysNeTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.always_ne_trgeometry_trgeometry(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqGeoTrgeometry wraps MEOS C function ever_eq_geo_trgeometry. -func EverEqGeoTrgeometry(gs *Geom, temp *Temporal) int { +func EverEqGeoTrgeometry(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_geo_trgeometry(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTrgeometryGeo wraps MEOS C function ever_eq_trgeometry_geo. -func EverEqTrgeometryGeo(temp *Temporal, gs *Geom) int { +func EverEqTrgeometryGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_trgeometry_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverEqTrgeometryTrgeometry wraps MEOS C function ever_eq_trgeometry_trgeometry. -func EverEqTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) int { +func EverEqTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_eq_trgeometry_trgeometry(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeGeoTrgeometry wraps MEOS C function ever_ne_geo_trgeometry. -func EverNeGeoTrgeometry(gs *Geom, temp *Temporal) int { +func EverNeGeoTrgeometry(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_geo_trgeometry(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTrgeometryGeo wraps MEOS C function ever_ne_trgeometry_geo. -func EverNeTrgeometryGeo(temp *Temporal, gs *Geom) int { +func EverNeTrgeometryGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_trgeometry_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EverNeTrgeometryTrgeometry wraps MEOS C function ever_ne_trgeometry_trgeometry. -func EverNeTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) int { +func EverNeTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ever_ne_trgeometry_trgeometry(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // TeqGeoTrgeometry wraps MEOS C function teq_geo_trgeometry. -func TeqGeoTrgeometry(gs *Geom, temp *Temporal) *Temporal { +func TeqGeoTrgeometry(gs *Geom, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_geo_trgeometry(gs._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TeqTrgeometryGeo wraps MEOS C function teq_trgeometry_geo. -func TeqTrgeometryGeo(temp *Temporal, gs *Geom) *Temporal { +func TeqTrgeometryGeo(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.teq_trgeometry_geo(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneGeoTrgeometry wraps MEOS C function tne_geo_trgeometry. -func TneGeoTrgeometry(gs *Geom, temp *Temporal) *Temporal { +func TneGeoTrgeometry(gs *Geom, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_geo_trgeometry(gs._inner, temp._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // TneTrgeometryGeo wraps MEOS C function tne_trgeometry_geo. -func TneTrgeometryGeo(temp *Temporal, gs *Geom) *Temporal { +func TneTrgeometryGeo(temp *Temporal, gs *Geom) (_r0 *Temporal, _err error) { + C.meos_errno_reset() _cret := C.tne_trgeometry_geo(temp._inner, gs._inner) - return &Temporal{_inner: _cret} + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil } // EcontainsGeoTrgeometry wraps MEOS C function econtains_geo_trgeometry. -func EcontainsGeoTrgeometry(gs *Geom, temp *Temporal) int { +func EcontainsGeoTrgeometry(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.econtains_geo_trgeometry(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AcontainsGeoTrgeometry wraps MEOS C function acontains_geo_trgeometry. -func AcontainsGeoTrgeometry(gs *Geom, temp *Temporal) int { +func AcontainsGeoTrgeometry(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.acontains_geo_trgeometry(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EcoversGeoTrgeometry wraps MEOS C function ecovers_geo_trgeometry. -func EcoversGeoTrgeometry(gs *Geom, temp *Temporal) int { +func EcoversGeoTrgeometry(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ecovers_geo_trgeometry(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AcoversGeoTrgeometry wraps MEOS C function acovers_geo_trgeometry. -func AcoversGeoTrgeometry(gs *Geom, temp *Temporal) int { +func AcoversGeoTrgeometry(gs *Geom, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.acovers_geo_trgeometry(gs._inner, temp._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EcoversTrgeometryGeo wraps MEOS C function ecovers_trgeometry_geo. -func EcoversTrgeometryGeo(temp *Temporal, gs *Geom) int { +func EcoversTrgeometryGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.ecovers_trgeometry_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AcoversTrgeometryGeo wraps MEOS C function acovers_trgeometry_geo. -func AcoversTrgeometryGeo(temp *Temporal, gs *Geom) int { +func AcoversTrgeometryGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.acovers_trgeometry_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EdisjointTrgeometryGeo wraps MEOS C function edisjoint_trgeometry_geo. -func EdisjointTrgeometryGeo(temp *Temporal, gs *Geom) int { +func EdisjointTrgeometryGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.edisjoint_trgeometry_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AdisjointTrgeometryGeo wraps MEOS C function adisjoint_trgeometry_geo. -func AdisjointTrgeometryGeo(temp *Temporal, gs *Geom) int { +func AdisjointTrgeometryGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.adisjoint_trgeometry_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EintersectsTrgeometryGeo wraps MEOS C function eintersects_trgeometry_geo. -func EintersectsTrgeometryGeo(temp *Temporal, gs *Geom) int { +func EintersectsTrgeometryGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.eintersects_trgeometry_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AintersectsTrgeometryGeo wraps MEOS C function aintersects_trgeometry_geo. -func AintersectsTrgeometryGeo(temp *Temporal, gs *Geom) int { +func AintersectsTrgeometryGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.aintersects_trgeometry_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EtouchesTrgeometryGeo wraps MEOS C function etouches_trgeometry_geo. -func EtouchesTrgeometryGeo(temp *Temporal, gs *Geom) int { +func EtouchesTrgeometryGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.etouches_trgeometry_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AtouchesTrgeometryGeo wraps MEOS C function atouches_trgeometry_geo. -func AtouchesTrgeometryGeo(temp *Temporal, gs *Geom) int { +func AtouchesTrgeometryGeo(temp *Temporal, gs *Geom) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.atouches_trgeometry_geo(temp._inner, gs._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EdwithinTrgeometryGeo wraps MEOS C function edwithin_trgeometry_geo. -func EdwithinTrgeometryGeo(temp *Temporal, gs *Geom, dist float64) int { +func EdwithinTrgeometryGeo(temp *Temporal, gs *Geom, dist float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.edwithin_trgeometry_geo(temp._inner, gs._inner, C.double(dist)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AdwithinTrgeometryGeo wraps MEOS C function adwithin_trgeometry_geo. -func AdwithinTrgeometryGeo(temp *Temporal, gs *Geom, dist float64) int { +func AdwithinTrgeometryGeo(temp *Temporal, gs *Geom, dist float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.adwithin_trgeometry_geo(temp._inner, gs._inner, C.double(dist)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EdisjointTrgeometryTrgeometry wraps MEOS C function edisjoint_trgeometry_trgeometry. -func EdisjointTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) int { +func EdisjointTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.edisjoint_trgeometry_trgeometry(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AdisjointTrgeometryTrgeometry wraps MEOS C function adisjoint_trgeometry_trgeometry. -func AdisjointTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) int { +func AdisjointTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.adisjoint_trgeometry_trgeometry(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EintersectsTrgeometryTrgeometry wraps MEOS C function eintersects_trgeometry_trgeometry. -func EintersectsTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) int { +func EintersectsTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.eintersects_trgeometry_trgeometry(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AintersectsTrgeometryTrgeometry wraps MEOS C function aintersects_trgeometry_trgeometry. -func AintersectsTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) int { +func AintersectsTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.aintersects_trgeometry_trgeometry(temp1._inner, temp2._inner) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // EdwithinTrgeometryTrgeometry wraps MEOS C function edwithin_trgeometry_trgeometry. -func EdwithinTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal, dist float64) int { +func EdwithinTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal, dist float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.edwithin_trgeometry_trgeometry(temp1._inner, temp2._inner, C.double(dist)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } // AdwithinTrgeometryTrgeometry wraps MEOS C function adwithin_trgeometry_trgeometry. -func AdwithinTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal, dist float64) int { +func AdwithinTrgeometryTrgeometry(temp1 *Temporal, temp2 *Temporal, dist float64) (_r0 int, _err error) { + C.meos_errno_reset() _cret := C.adwithin_trgeometry_trgeometry(temp1._inner, temp2._inner, C.double(dist)) - return int(_cret) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil } diff --git a/tools/codegen.py b/tools/codegen.py index ce5ab93..a719ee6 100644 --- a/tools/codegen.py +++ b/tools/codegen.py @@ -56,8 +56,46 @@ "py_error_handler", "meos_initialize_error_handler", "meos_error", + # The errno accessors are the plumbing this generator's own error + # projection is built on: every emitted wrapper clears the errno before + # its call and reads it after. Wrapping them as ordinary functions would + # both expose that plumbing as public API and be self-defeating -- a + # generated MeosErrno() would reset the errno immediately before reading + # it, and so always report success. Callers get errors as Go errors. + "meos_errno", + "meos_errno_set", + "meos_errno_restore", + "meos_errno_reset", } +# The error projection ------------------------------------------------------ +# +# MEOS reports a failure out of band: the failing call sets a thread-local +# errno and returns a sentinel that is the maximum of its own return type. +# That sentinel can never answer the question by itself -- INT_MAX is a +# legitimate count, DBL_MAX a legitimate distance, and a bool has no spare +# value at all, so its failure is indistinguishable from a definite false. +# The out-of-band state is the only discriminator. +# +# Go's idiom for that channel is the trailing error result, so every emitted +# wrapper returns one. This is applied to 100% of the emitted surface with no +# per-function exception: a rule that held for only some functions would need +# a hand-maintained list, and the property would stop being checkable. +_ERRNO_RESET = "\tC.meos_errno_reset()" +_ERRNO_GUARD = "\tif _err = meosError(); _err != nil {\n\t\treturn\n\t}" + + +def _result_signature(all_returns: list[str]) -> str: + """Render the Go result list, with the projected error appended. + + The results are named so the error guard can return the zero value of + every result with a bare ``return``, which keeps the emitted guard one + shape for every function rather than a per-type zero-value expression. + """ + named = [f"_r{i} {go_type}" for i, go_type in enumerate(all_returns)] + named.append("_err error") + return f" ({', '.join(named)})" + # Type mapping ---------------------------------------------------------- @@ -516,11 +554,12 @@ def _emit_array_input_group(entry: dict, group: dict) -> EmittedFunc: sig_args = ", ".join(go_args) call = f"C.{_c_callee(c_name)}({', '.join(inner_args)})" body = "\n".join("\t" + d for d in deferred) - ret_sig = "" if return_c == "void" else f" {ret_go}" + ret_sig = _result_signature([] if return_c == "void" else [ret_go]) if return_c == "void": - tail = f"\t{call}" + tail = f"{_ERRNO_RESET}\n\t{call}\n{_ERRNO_GUARD}\n\treturn" else: - tail = f"\t_cret := {call}\n\treturn {ret_from_c.replace('$x', '_cret')}" + tail = (f"{_ERRNO_RESET}\n\t_cret := {call}\n{_ERRNO_GUARD}\n" + f"\treturn {ret_from_c.replace('$x', '_cret')}, nil") code = ( f"// {go_name} wraps MEOS C function {c_name}.\n" f"func {go_name}({sig_args}){ret_sig} {{\n" @@ -818,16 +857,12 @@ def classify_one(p, i): for go_type, _, _ in extra_returns: all_returns.append(go_type) - if len(all_returns) == 0: - ret_sig = "" - elif len(all_returns) == 1: - ret_sig = f" {all_returns[0]}" - else: - ret_sig = f" ({', '.join(all_returns)})" + ret_sig = _result_signature(all_returns) # Assemble Go body ---------------------------------------------------- body_lines = [] body_lines.extend("\t" + d for d in deferred) + body_lines.append(_ERRNO_RESET) call = f"C.{_c_callee(c_name)}({', '.join(inner_args)})" if is_array_return: @@ -840,13 +875,14 @@ def classify_one(p, i): else: count_expr = array_length_source body_lines.append(f"\tres := {call}") + body_lines.append(_ERRNO_GUARD) body_lines.append(f"\t_n := {count_expr}") if array_elem_go == "byte": # WKB byte buffer; cast (*C.uint8_t -> []byte via unsafe.Slice). body_lines.append("\t_slice := unsafe.Slice((*byte)(unsafe.Pointer(res)), _n)") body_lines.append("\t_out := make([]byte, _n)") body_lines.append("\tcopy(_out, _slice)") - body_lines.append("\treturn _out") + body_lines.append("\treturn _out, nil") else: base, stars = _array_return_info(return_c) elem_c = f"*C.{base}" if stars == 2 else f"C.{base}" @@ -855,26 +891,30 @@ def classify_one(p, i): body_lines.append("\tfor _i, _e := range _slice {") body_lines.append(f"\t\t_out[_i] = {array_elem_ctor.replace('$x', '_e')}") body_lines.append("\t}") - body_lines.append("\treturn _out") + body_lines.append("\treturn _out, nil") elif return_c == "void": if extra_returns: body_lines.append(f"\t{call}") + body_lines.append(_ERRNO_GUARD) tail = ", ".join(c2g for _, _, c2g in extra_returns) tail = _expand_slice_markers(tail, body_lines, array_count_local, array_length_source) - body_lines.append(f"\treturn {tail}") + body_lines.append(f"\treturn {tail}, nil") else: body_lines.append(f"\t{call}") + body_lines.append(_ERRNO_GUARD) + body_lines.append("\treturn nil") else: # ``_cret`` (not ``res``) so the result local never collides with a C # parameter named ``res`` (e.g. h3_uncompact_cells' resolution arg). body_lines.append(f"\t_cret := {call}") + body_lines.append(_ERRNO_GUARD) return_expr = ret_from_c.replace("$x", "_cret") if extra_returns: tail = ", ".join(c2g for _, _, c2g in extra_returns) tail = _expand_slice_markers(tail, body_lines, array_count_local, array_length_source) - body_lines.append(f"\treturn {return_expr}, {tail}") + body_lines.append(f"\treturn {return_expr}, {tail}, nil") else: - body_lines.append(f"\treturn {return_expr}") + body_lines.append(f"\treturn {return_expr}, nil") code = ( f"// {go_name} wraps MEOS C function {c_name}.\n" @@ -990,6 +1030,39 @@ def _todo_stub(c_name: str, reason: str) -> str: #include "meos_pointcloud.h" */ import "C" + +import "fmt" + +// MeosError reports that the MEOS call behind a wrapper failed, carrying the +// error code MEOS recorded for it. +type MeosError struct { + Code int +} + +func (e *MeosError) Error() string { + return fmt.Sprintf("meos: error %d", e.Code) +} + +// meosError reads the out-of-band state MEOS sets when a call fails, and +// clears it so a stale code cannot condemn the next, innocent call. It +// returns nil when the call succeeded. +// +// The returned value can never answer this on its own: every MEOS sentinel is +// a legitimate value of its own return type -- INT_MAX is a count, DBL_MAX is +// a distance, and a bool has no spare value at all. So no generated wrapper +// compares against a sentinel; each consults this instead. +// +// Install meos_initialize_noexit_error_handler (wrapped as +// MeosInitializeNoexitErrorHandler) once per process before calling anything +// else, on every thread that calls MEOS: the default handler ends the +// process, and meos_initialize resets the handler per thread. +func meosError() error { + if code := int(C.meos_errno()); code != 0 { + C.meos_errno_reset() + return &MeosError{Code: code} + } + return nil +} """ _PER_HEADER_PREAMBLE = """package functions