From b95df42604ad8b6e2a63d257f55ee21a6135b309 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 3 Sep 2026 01:05:04 +0200 Subject: [PATCH 1/2] Refresh the committed functions snapshot against the MEOS surface WITNESS: `go build ./functions` against a libmeos built from MobilityDB 40eb373334 at -DALL=ON reports functions/meos_meos_internal_geo.go:115:2: could not determine kind of name for C.geo_set_srid_int MEOS publishes `geo_set_srid`, and `geo_set_srid_int` appears in neither the installed headers nor the exported symbols of libmeos.so, so the snapshot names a spelling the library does not carry. MEASURED: regenerating with `python3 tools/codegen.py` against a catalog derived from that same commit moves five files, +900 -35, and `go build ./functions` then exits 0. The retired name drops to 0 occurrences while `geo_set_srid` remains the one spelling present. WHY: `functions/` is the snapshot a `go get` consumer compiles, so a name MEOS has retired reaches consumers as a build failure in their own tree. The snapshot is a projection of the catalog and carries no independent authority; where the two disagree the catalog is right. --- functions/meos_meos.go | 11 + functions/meos_meos_internal.go | 11 - functions/meos_meos_internal_geo.go | 11 - functions/meos_meos_pointcloud.go | 11 - functions/meos_meos_pose.go | 891 +++++++++++++++++++++++++++- 5 files changed, 900 insertions(+), 35 deletions(-) diff --git a/functions/meos_meos.go b/functions/meos_meos.go index 9d2ae8c..04acf0e 100644 --- a/functions/meos_meos.go +++ b/functions/meos_meos.go @@ -13518,6 +13518,17 @@ func OverlapsTemporalTemporal(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err } +// TemporalTimeOverlaps wraps MEOS C function temporal_time_overlaps. +func TemporalTimeOverlaps(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.temporal_time_overlaps(temp1._inner, temp2._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + // OverlapsTemporalTstzspan wraps MEOS C function overlaps_temporal_tstzspan. func OverlapsTemporalTstzspan(temp *Temporal, s *Span) (_r0 bool, _err error) { C.meos_errno_reset() diff --git a/functions/meos_meos_internal.go b/functions/meos_meos_internal.go index 358e265..278582b 100644 --- a/functions/meos_meos_internal.go +++ b/functions/meos_meos_internal.go @@ -1376,17 +1376,6 @@ func TemporalSetTstzspan(temp *Temporal, s *Span) (_err error) { } -// TemporalTimeOverlaps wraps MEOS C function temporal_time_overlaps. -func TemporalTimeOverlaps(temp1 *Temporal, temp2 *Temporal) (_r0 bool, _err error) { - C.meos_errno_reset() - _cret := C.temporal_time_overlaps(temp1._inner, temp2._inner) - if _err = meosError(); _err != nil { - return - } - return bool(_cret), nil -} - - // TinstantSetTstzspan wraps MEOS C function tinstant_set_tstzspan. func TinstantSetTstzspan(inst *TInstant, s *Span) (_err error) { C.meos_errno_reset() diff --git a/functions/meos_meos_internal_geo.go b/functions/meos_meos_internal_geo.go index 698d190..6a7c334 100644 --- a/functions/meos_meos_internal_geo.go +++ b/functions/meos_meos_internal_geo.go @@ -109,17 +109,6 @@ func PointRound(gs *Geom, maxdd int) (_r0 *Geom, _err error) { } -// GeoSetSRIDInt wraps MEOS C function geo_set_srid_int. -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) (_r0 *STBox, _err error) { var _out_result C.STBox diff --git a/functions/meos_meos_pointcloud.go b/functions/meos_meos_pointcloud.go index 25bb119..c0f6b08 100644 --- a/functions/meos_meos_pointcloud.go +++ b/functions/meos_meos_pointcloud.go @@ -1664,17 +1664,6 @@ func OverafterTpcboxTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { } -// EnsureSamePcidTpcbox wraps MEOS C function ensure_same_pcid_tpcbox. -func EnsureSamePcidTpcbox(box1 *TPCBox, box2 *TPCBox) (_r0 bool, _err error) { - C.meos_errno_reset() - _cret := C.ensure_same_pcid_tpcbox(box1._inner, box2._inner) - if _err = meosError(); _err != nil { - return - } - return bool(_cret), nil -} - - // TpointcloudToTgeompoint wraps MEOS C function tpointcloud_to_tgeompoint. func TpointcloudToTgeompoint(temp *Temporal) (_r0 *Temporal, _err error) { C.meos_errno_reset() diff --git a/functions/meos_meos_pose.go b/functions/meos_meos_pose.go index 0c05c61..9f35b17 100644 --- a/functions/meos_meos_pose.go +++ b/functions/meos_meos_pose.go @@ -1051,9 +1051,9 @@ func TposeseqsetFromBaseTstzspanset(pose *Pose, ss *SpanSet, interp Interpolatio // TposeMake wraps MEOS C function tpose_make. -func TposeMake(tpoint *Temporal, tradius *Temporal) (_r0 *Temporal, _err error) { +func TposeMake(tpoint *Temporal, ttheta *Temporal) (_r0 *Temporal, _err error) { C.meos_errno_reset() - _cret := C.tpose_make(tpoint._inner, tradius._inner) + _cret := C.tpose_make(tpoint._inner, ttheta._inner) if _err = meosError(); _err != nil { return } @@ -1612,3 +1612,890 @@ func TneTposePose(temp *Temporal, pose *Pose) (_r0 *Temporal, _err error) { return &Temporal{_inner: _cret}, nil } + +// PosechainIn wraps MEOS C function posechain_in. +func PosechainIn(str string) (_r0 unsafe.Pointer, _err error) { + _c_str := C.CString(str) + defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() + _cret := C.posechain_in(_c_str) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} + + +// PosechainOut wraps MEOS C function posechain_out. +func PosechainOut(pc unsafe.Pointer, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() + _cret := C.posechain_out((*C.PoseChain)(unsafe.Pointer(pc)), C.int(maxdd)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil +} + + +// PosechainAsText wraps MEOS C function posechain_as_text. +func PosechainAsText(pc unsafe.Pointer, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() + _cret := C.posechain_as_text((*C.PoseChain)(unsafe.Pointer(pc)), C.int(maxdd)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil +} + + +// PosechainAsEWKT wraps MEOS C function posechain_as_ewkt. +func PosechainAsEWKT(pc unsafe.Pointer, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() + _cret := C.posechain_as_ewkt((*C.PoseChain)(unsafe.Pointer(pc)), C.int(maxdd)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil +} + + +// PosechainAsWKB wraps MEOS C function posechain_as_wkb. +func PosechainAsWKB(pc unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.posechain_as_wkb((*C.PoseChain)(unsafe.Pointer(pc)), C.uint8_t(variant), (*C.size_t)(unsafe.Pointer(size_out))) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} + + +// PosechainAsHexwkb wraps MEOS C function posechain_as_hexwkb. +func PosechainAsHexwkb(pc unsafe.Pointer, variant uint8, size_out unsafe.Pointer) (_r0 string, _err error) { + C.meos_errno_reset() + _cret := C.posechain_as_hexwkb((*C.PoseChain)(unsafe.Pointer(pc)), C.uint8_t(variant), (*C.size_t)(unsafe.Pointer(size_out))) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil +} + + +// PosechainFromWKB wraps MEOS C function posechain_from_wkb. +func PosechainFromWKB(wkb unsafe.Pointer, size uint) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.posechain_from_wkb((*C.uint8_t)(unsafe.Pointer(wkb)), C.size_t(size)) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} + + +// PosechainFromHexwkb wraps MEOS C function posechain_from_hexwkb. +func PosechainFromHexwkb(hexwkb string) (_r0 unsafe.Pointer, _err error) { + _c_hexwkb := C.CString(hexwkb) + defer C.free(unsafe.Pointer(_c_hexwkb)) + C.meos_errno_reset() + _cret := C.posechain_from_hexwkb(_c_hexwkb) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} + + +// PosechainMake wraps MEOS C function posechain_make. +func PosechainMake(poses unsafe.Pointer, count int) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.posechain_make((**C.Pose)(unsafe.Pointer(poses)), C.int(count)) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} + + +// PosechainCopy wraps MEOS C function posechain_copy. +func PosechainCopy(pc unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.posechain_copy((*C.PoseChain)(unsafe.Pointer(pc))) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} + + +// PosechainAppend wraps MEOS C function posechain_append. +func PosechainAppend(pc unsafe.Pointer, pose *Pose) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.posechain_append((*C.PoseChain)(unsafe.Pointer(pc)), pose._inner) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} + + +// PoseToPosechain wraps MEOS C function pose_to_posechain. +func PoseToPosechain(pose *Pose) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.pose_to_posechain(pose._inner) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} + + +// PosechainToPose wraps MEOS C function posechain_to_pose. +func PosechainToPose(pc unsafe.Pointer) (_r0 *Pose, _err error) { + C.meos_errno_reset() + _cret := C.posechain_to_pose((*C.PoseChain)(unsafe.Pointer(pc))) + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil +} + + +// PosechainPrefixPose wraps MEOS C function posechain_prefix_pose. +func PosechainPrefixPose(pc unsafe.Pointer, n int) (_r0 *Pose, _err error) { + C.meos_errno_reset() + _cret := C.posechain_prefix_pose((*C.PoseChain)(unsafe.Pointer(pc)), C.int(n)) + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil +} + + +// PosechainToPoint wraps MEOS C function posechain_to_point. +func PosechainToPoint(pc unsafe.Pointer) (_r0 *Geom, _err error) { + C.meos_errno_reset() + _cret := C.posechain_to_point((*C.PoseChain)(unsafe.Pointer(pc))) + if _err = meosError(); _err != nil { + return + } + return &Geom{_inner: _cret}, nil +} + + +// PosechainToSTBOX wraps MEOS C function posechain_to_stbox. +func PosechainToSTBOX(pc unsafe.Pointer) (_r0 *STBox, _err error) { + C.meos_errno_reset() + _cret := C.posechain_to_stbox((*C.PoseChain)(unsafe.Pointer(pc))) + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil +} + + +// PosechainTimestamptzToSTBOX wraps MEOS C function posechain_timestamptz_to_stbox. +func PosechainTimestamptzToSTBOX(pc unsafe.Pointer, t int64) (_r0 *STBox, _err error) { + C.meos_errno_reset() + _cret := C.posechain_timestamptz_to_stbox((*C.PoseChain)(unsafe.Pointer(pc)), C.TimestampTz(t)) + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil +} + + +// PosechainTstzspanToSTBOX wraps MEOS C function posechain_tstzspan_to_stbox. +func PosechainTstzspanToSTBOX(pc unsafe.Pointer, s *Span) (_r0 *STBox, _err error) { + C.meos_errno_reset() + _cret := C.posechain_tstzspan_to_stbox((*C.PoseChain)(unsafe.Pointer(pc)), s._inner) + if _err = meosError(); _err != nil { + return + } + return &STBox{_inner: _cret}, nil +} + + +// PosechainNumPoses wraps MEOS C function posechain_num_poses. +func PosechainNumPoses(pc unsafe.Pointer) (_r0 int, _err error) { + C.meos_errno_reset() + _cret := C.posechain_num_poses((*C.PoseChain)(unsafe.Pointer(pc))) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil +} + + +// PosechainStartPose wraps MEOS C function posechain_start_pose. +func PosechainStartPose(pc unsafe.Pointer) (_r0 *Pose, _err error) { + C.meos_errno_reset() + _cret := C.posechain_start_pose((*C.PoseChain)(unsafe.Pointer(pc))) + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil +} + + +// PosechainEndPose wraps MEOS C function posechain_end_pose. +func PosechainEndPose(pc unsafe.Pointer) (_r0 *Pose, _err error) { + C.meos_errno_reset() + _cret := C.posechain_end_pose((*C.PoseChain)(unsafe.Pointer(pc))) + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil +} + + +// PosechainPoseN wraps MEOS C function posechain_pose_n. +func PosechainPoseN(pc unsafe.Pointer, n int) (_r0 *Pose, _err error) { + C.meos_errno_reset() + _cret := C.posechain_pose_n((*C.PoseChain)(unsafe.Pointer(pc)), C.int(n)) + if _err = meosError(); _err != nil { + return + } + return &Pose{_inner: _cret}, nil +} + + +// PosechainPoses wraps MEOS C function posechain_poses. +func PosechainPoses(pc unsafe.Pointer, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.posechain_poses((*C.PoseChain)(unsafe.Pointer(pc)), (*C.int)(unsafe.Pointer(count))) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} + + +// PosechainHash wraps MEOS C function posechain_hash. +func PosechainHash(pc unsafe.Pointer) (_r0 uint32, _err error) { + C.meos_errno_reset() + _cret := C.posechain_hash((*C.PoseChain)(unsafe.Pointer(pc))) + if _err = meosError(); _err != nil { + return + } + return uint32(_cret), nil +} + + +// PosechainHashExtended wraps MEOS C function posechain_hash_extended. +func PosechainHashExtended(pc unsafe.Pointer, seed uint64) (_r0 uint64, _err error) { + C.meos_errno_reset() + _cret := C.posechain_hash_extended((*C.PoseChain)(unsafe.Pointer(pc)), C.uint64_t(seed)) + if _err = meosError(); _err != nil { + return + } + return uint64(_cret), nil +} + + +// PosechainRound wraps MEOS C function posechain_round. +func PosechainRound(pc unsafe.Pointer, maxdd int) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.posechain_round((*C.PoseChain)(unsafe.Pointer(pc)), C.int(maxdd)) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} + + +// PosechainSRID wraps MEOS C function posechain_srid. +func PosechainSRID(pc unsafe.Pointer) (_r0 int32, _err error) { + C.meos_errno_reset() + _cret := C.posechain_srid((*C.PoseChain)(unsafe.Pointer(pc))) + if _err = meosError(); _err != nil { + return + } + return int32(_cret), nil +} + + +// PosechainSetSRID wraps MEOS C function posechain_set_srid. +func PosechainSetSRID(pc unsafe.Pointer, srid int32) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.posechain_set_srid((*C.PoseChain)(unsafe.Pointer(pc)), C.int32_t(srid)) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} + + +// PosechainTransform wraps MEOS C function posechain_transform. +func PosechainTransform(pc unsafe.Pointer, srid_to int32) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.posechain_transform((*C.PoseChain)(unsafe.Pointer(pc)), C.int32_t(srid_to)) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} + + +// PosechainTransformPipeline wraps MEOS C function posechain_transform_pipeline. +func PosechainTransformPipeline(pc unsafe.Pointer, pipeline string, srid_to int32, is_forward bool) (_r0 unsafe.Pointer, _err error) { + _c_pipeline := C.CString(pipeline) + defer C.free(unsafe.Pointer(_c_pipeline)) + C.meos_errno_reset() + _cret := C.posechain_transform_pipeline((*C.PoseChain)(unsafe.Pointer(pc)), _c_pipeline, C.int32_t(srid_to), C.bool(is_forward)) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} + + +// TposechainFromGeopose wraps MEOS C function tposechain_from_geopose. +func TposechainFromGeopose(json string) (_r0 *Temporal, _err error) { + _c_json := C.CString(json) + defer C.free(unsafe.Pointer(_c_json)) + C.meos_errno_reset() + _cret := C.tposechain_from_geopose(_c_json) + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil +} + + +// TposechainAsGeopose wraps MEOS C function tposechain_as_geopose. +func TposechainAsGeopose(temp *Temporal, precision int) (_r0 string, _err error) { + C.meos_errno_reset() + _cret := C.tposechain_as_geopose(temp._inner, C.int(precision)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil +} + + +// TposechainarrAsGeopose wraps MEOS C function tposechainarr_as_geopose. +func TposechainarrAsGeopose(temparr unsafe.Pointer, count int, precision int) (_r0 string, _err error) { + C.meos_errno_reset() + _cret := C.tposechainarr_as_geopose((**C.Temporal)(unsafe.Pointer(temparr)), C.int(count), C.int(precision)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil +} + + +// PosechainEq wraps MEOS C function posechain_eq. +func PosechainEq(pc1 unsafe.Pointer, pc2 unsafe.Pointer) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.posechain_eq((*C.PoseChain)(unsafe.Pointer(pc1)), (*C.PoseChain)(unsafe.Pointer(pc2))) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// PosechainNe wraps MEOS C function posechain_ne. +func PosechainNe(pc1 unsafe.Pointer, pc2 unsafe.Pointer) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.posechain_ne((*C.PoseChain)(unsafe.Pointer(pc1)), (*C.PoseChain)(unsafe.Pointer(pc2))) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// PosechainSame wraps MEOS C function posechain_same. +func PosechainSame(pc1 unsafe.Pointer, pc2 unsafe.Pointer) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.posechain_same((*C.PoseChain)(unsafe.Pointer(pc1)), (*C.PoseChain)(unsafe.Pointer(pc2))) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// PosechainNsame wraps MEOS C function posechain_nsame. +func PosechainNsame(pc1 unsafe.Pointer, pc2 unsafe.Pointer) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.posechain_nsame((*C.PoseChain)(unsafe.Pointer(pc1)), (*C.PoseChain)(unsafe.Pointer(pc2))) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// PosechainCmp wraps MEOS C function posechain_cmp. +func PosechainCmp(pc1 unsafe.Pointer, pc2 unsafe.Pointer) (_r0 int, _err error) { + C.meos_errno_reset() + _cret := C.posechain_cmp((*C.PoseChain)(unsafe.Pointer(pc1)), (*C.PoseChain)(unsafe.Pointer(pc2))) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil +} + + +// PosechainLt wraps MEOS C function posechain_lt. +func PosechainLt(pc1 unsafe.Pointer, pc2 unsafe.Pointer) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.posechain_lt((*C.PoseChain)(unsafe.Pointer(pc1)), (*C.PoseChain)(unsafe.Pointer(pc2))) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// PosechainLe wraps MEOS C function posechain_le. +func PosechainLe(pc1 unsafe.Pointer, pc2 unsafe.Pointer) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.posechain_le((*C.PoseChain)(unsafe.Pointer(pc1)), (*C.PoseChain)(unsafe.Pointer(pc2))) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// PosechainGt wraps MEOS C function posechain_gt. +func PosechainGt(pc1 unsafe.Pointer, pc2 unsafe.Pointer) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.posechain_gt((*C.PoseChain)(unsafe.Pointer(pc1)), (*C.PoseChain)(unsafe.Pointer(pc2))) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// PosechainGe wraps MEOS C function posechain_ge. +func PosechainGe(pc1 unsafe.Pointer, pc2 unsafe.Pointer) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.posechain_ge((*C.PoseChain)(unsafe.Pointer(pc1)), (*C.PoseChain)(unsafe.Pointer(pc2))) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// PosechainsetIn wraps MEOS C function posechainset_in. +func PosechainsetIn(str string) (_r0 *Set, _err error) { + _c_str := C.CString(str) + defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() + _cret := C.posechainset_in(_c_str) + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil +} + + +// PosechainsetOut wraps MEOS C function posechainset_out. +func PosechainsetOut(s *Set, maxdd int) (_r0 string, _err error) { + C.meos_errno_reset() + _cret := C.posechainset_out(s._inner, C.int(maxdd)) + if _err = meosError(); _err != nil { + return + } + return C.GoString(_cret), nil +} + + +// PosechainsetMake wraps MEOS C function posechainset_make. +func PosechainsetMake(values unsafe.Pointer, count int) (_r0 *Set, _err error) { + C.meos_errno_reset() + _cret := C.posechainset_make((**C.PoseChain)(unsafe.Pointer(values)), C.int(count)) + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil +} + + +// PosechainToSet wraps MEOS C function posechain_to_set. +func PosechainToSet(pc unsafe.Pointer) (_r0 *Set, _err error) { + C.meos_errno_reset() + _cret := C.posechain_to_set((*C.PoseChain)(unsafe.Pointer(pc))) + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil +} + + +// PosechainsetEndValue wraps MEOS C function posechainset_end_value. +func PosechainsetEndValue(s *Set) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.posechainset_end_value(s._inner) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} + + +// PosechainsetStartValue wraps MEOS C function posechainset_start_value. +func PosechainsetStartValue(s *Set) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.posechainset_start_value(s._inner) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} + + +// TODO posechainset_value_n: unhandled OUTPUT_SCALAR shape PoseChain ** +// func PosechainsetValueN(...) { /* not yet handled by codegen */ } + + +// PosechainsetValues wraps MEOS C function posechainset_values. +func PosechainsetValues(s *Set, count unsafe.Pointer) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.posechainset_values(s._inner, (*C.int)(unsafe.Pointer(count))) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} + + +// ContainedPosechainSet wraps MEOS C function contained_posechain_set. +func ContainedPosechainSet(pc unsafe.Pointer, s *Set) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.contained_posechain_set((*C.PoseChain)(unsafe.Pointer(pc)), s._inner) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// ContainsSetPosechain wraps MEOS C function contains_set_posechain. +func ContainsSetPosechain(s *Set, pc unsafe.Pointer) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.contains_set_posechain(s._inner, (*C.PoseChain)(unsafe.Pointer(pc))) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} + + +// IntersectionPosechainSet wraps MEOS C function intersection_posechain_set. +func IntersectionPosechainSet(pc unsafe.Pointer, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() + _cret := C.intersection_posechain_set((*C.PoseChain)(unsafe.Pointer(pc)), s._inner) + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil +} + + +// IntersectionSetPosechain wraps MEOS C function intersection_set_posechain. +func IntersectionSetPosechain(s *Set, pc unsafe.Pointer) (_r0 *Set, _err error) { + C.meos_errno_reset() + _cret := C.intersection_set_posechain(s._inner, (*C.PoseChain)(unsafe.Pointer(pc))) + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil +} + + +// MinusPosechainSet wraps MEOS C function minus_posechain_set. +func MinusPosechainSet(pc unsafe.Pointer, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() + _cret := C.minus_posechain_set((*C.PoseChain)(unsafe.Pointer(pc)), s._inner) + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil +} + + +// MinusSetPosechain wraps MEOS C function minus_set_posechain. +func MinusSetPosechain(s *Set, pc unsafe.Pointer) (_r0 *Set, _err error) { + C.meos_errno_reset() + _cret := C.minus_set_posechain(s._inner, (*C.PoseChain)(unsafe.Pointer(pc))) + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil +} + + +// PosechainUnionTransfn wraps MEOS C function posechain_union_transfn. +func PosechainUnionTransfn(state *Set, pc unsafe.Pointer) (_r0 *Set, _err error) { + C.meos_errno_reset() + _cret := C.posechain_union_transfn(state._inner, (*C.PoseChain)(unsafe.Pointer(pc))) + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil +} + + +// UnionPosechainSet wraps MEOS C function union_posechain_set. +func UnionPosechainSet(pc unsafe.Pointer, s *Set) (_r0 *Set, _err error) { + C.meos_errno_reset() + _cret := C.gunion_posechain_set((*C.PoseChain)(unsafe.Pointer(pc)), s._inner) + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil +} + + +// UnionSetPosechain wraps MEOS C function union_set_posechain. +func UnionSetPosechain(s *Set, pc unsafe.Pointer) (_r0 *Set, _err error) { + C.meos_errno_reset() + _cret := C.gunion_set_posechain(s._inner, (*C.PoseChain)(unsafe.Pointer(pc))) + if _err = meosError(); _err != nil { + return + } + return &Set{_inner: _cret}, nil +} + + +// TposechainIn wraps MEOS C function tposechain_in. +func TposechainIn(str string) (_r0 *Temporal, _err error) { + _c_str := C.CString(str) + defer C.free(unsafe.Pointer(_c_str)) + C.meos_errno_reset() + _cret := C.tposechain_in(_c_str) + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil +} + + +// TposechainFromMFJSON wraps MEOS C function tposechain_from_mfjson. +func TposechainFromMFJSON(mfjson string) (_r0 *Temporal, _err error) { + _c_mfjson := C.CString(mfjson) + defer C.free(unsafe.Pointer(_c_mfjson)) + C.meos_errno_reset() + _cret := C.tposechain_from_mfjson(_c_mfjson) + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil +} + + +// TposechainFromBaseTemp wraps MEOS C function tposechain_from_base_temp. +func TposechainFromBaseTemp(pc unsafe.Pointer, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() + _cret := C.tposechain_from_base_temp((*C.PoseChain)(unsafe.Pointer(pc)), temp._inner) + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil +} + + +// TposechainToTpose wraps MEOS C function tposechain_to_tpose. +func TposechainToTpose(temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() + _cret := C.tposechain_to_tpose(temp._inner) + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil +} + + +// TposechainNumPoses wraps MEOS C function tposechain_num_poses. +func TposechainNumPoses(temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() + _cret := C.tposechain_num_poses(temp._inner) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil +} + + +// AlwaysEqPosechainTposechain wraps MEOS C function always_eq_posechain_tposechain. +func AlwaysEqPosechainTposechain(posechain unsafe.Pointer, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() + _cret := C.always_eq_posechain_tposechain((*C.PoseChain)(unsafe.Pointer(posechain)), temp._inner) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil +} + + +// AlwaysEqTposechainPosechain wraps MEOS C function always_eq_tposechain_posechain. +func AlwaysEqTposechainPosechain(temp *Temporal, posechain unsafe.Pointer) (_r0 int, _err error) { + C.meos_errno_reset() + _cret := C.always_eq_tposechain_posechain(temp._inner, (*C.PoseChain)(unsafe.Pointer(posechain))) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil +} + + +// AlwaysEqTposechainTposechain wraps MEOS C function always_eq_tposechain_tposechain. +func AlwaysEqTposechainTposechain(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() + _cret := C.always_eq_tposechain_tposechain(temp1._inner, temp2._inner) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil +} + + +// AlwaysNePosechainTposechain wraps MEOS C function always_ne_posechain_tposechain. +func AlwaysNePosechainTposechain(posechain unsafe.Pointer, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() + _cret := C.always_ne_posechain_tposechain((*C.PoseChain)(unsafe.Pointer(posechain)), temp._inner) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil +} + + +// AlwaysNeTposechainPosechain wraps MEOS C function always_ne_tposechain_posechain. +func AlwaysNeTposechainPosechain(temp *Temporal, posechain unsafe.Pointer) (_r0 int, _err error) { + C.meos_errno_reset() + _cret := C.always_ne_tposechain_posechain(temp._inner, (*C.PoseChain)(unsafe.Pointer(posechain))) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil +} + + +// AlwaysNeTposechainTposechain wraps MEOS C function always_ne_tposechain_tposechain. +func AlwaysNeTposechainTposechain(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() + _cret := C.always_ne_tposechain_tposechain(temp1._inner, temp2._inner) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil +} + + +// EverEqPosechainTposechain wraps MEOS C function ever_eq_posechain_tposechain. +func EverEqPosechainTposechain(posechain unsafe.Pointer, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() + _cret := C.ever_eq_posechain_tposechain((*C.PoseChain)(unsafe.Pointer(posechain)), temp._inner) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil +} + + +// EverEqTposechainPosechain wraps MEOS C function ever_eq_tposechain_posechain. +func EverEqTposechainPosechain(temp *Temporal, posechain unsafe.Pointer) (_r0 int, _err error) { + C.meos_errno_reset() + _cret := C.ever_eq_tposechain_posechain(temp._inner, (*C.PoseChain)(unsafe.Pointer(posechain))) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil +} + + +// EverEqTposechainTposechain wraps MEOS C function ever_eq_tposechain_tposechain. +func EverEqTposechainTposechain(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() + _cret := C.ever_eq_tposechain_tposechain(temp1._inner, temp2._inner) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil +} + + +// EverNePosechainTposechain wraps MEOS C function ever_ne_posechain_tposechain. +func EverNePosechainTposechain(posechain unsafe.Pointer, temp *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() + _cret := C.ever_ne_posechain_tposechain((*C.PoseChain)(unsafe.Pointer(posechain)), temp._inner) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil +} + + +// EverNeTposechainPosechain wraps MEOS C function ever_ne_tposechain_posechain. +func EverNeTposechainPosechain(temp *Temporal, posechain unsafe.Pointer) (_r0 int, _err error) { + C.meos_errno_reset() + _cret := C.ever_ne_tposechain_posechain(temp._inner, (*C.PoseChain)(unsafe.Pointer(posechain))) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil +} + + +// EverNeTposechainTposechain wraps MEOS C function ever_ne_tposechain_tposechain. +func EverNeTposechainTposechain(temp1 *Temporal, temp2 *Temporal) (_r0 int, _err error) { + C.meos_errno_reset() + _cret := C.ever_ne_tposechain_tposechain(temp1._inner, temp2._inner) + if _err = meosError(); _err != nil { + return + } + return int(_cret), nil +} + + +// TeqPosechainTposechain wraps MEOS C function teq_posechain_tposechain. +func TeqPosechainTposechain(posechain unsafe.Pointer, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() + _cret := C.teq_posechain_tposechain((*C.PoseChain)(unsafe.Pointer(posechain)), temp._inner) + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil +} + + +// TeqTposechainPosechain wraps MEOS C function teq_tposechain_posechain. +func TeqTposechainPosechain(temp *Temporal, posechain unsafe.Pointer) (_r0 *Temporal, _err error) { + C.meos_errno_reset() + _cret := C.teq_tposechain_posechain(temp._inner, (*C.PoseChain)(unsafe.Pointer(posechain))) + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil +} + + +// TnePosechainTposechain wraps MEOS C function tne_posechain_tposechain. +func TnePosechainTposechain(posechain unsafe.Pointer, temp *Temporal) (_r0 *Temporal, _err error) { + C.meos_errno_reset() + _cret := C.tne_posechain_tposechain((*C.PoseChain)(unsafe.Pointer(posechain)), temp._inner) + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil +} + + +// TneTposechainPosechain wraps MEOS C function tne_tposechain_posechain. +func TneTposechainPosechain(temp *Temporal, posechain unsafe.Pointer) (_r0 *Temporal, _err error) { + C.meos_errno_reset() + _cret := C.tne_tposechain_posechain(temp._inner, (*C.PoseChain)(unsafe.Pointer(posechain))) + if _err = meosError(); _err != nil { + return + } + return &Temporal{_inner: _cret}, nil +} + From b418561a15ea3945c218346e31fc9cd8b4394b54 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 3 Sep 2026 00:54:40 +0200 Subject: [PATCH 2/2] Run the gomeos package's own tests The build job installs an all-families libmeos and then collects no test from the gomeos package, which holds the binding's only behavioural tests: 115 Example functions whose `// Output:` block is the assertion. WITNESS: `ExampleFloatSpan_Distance` asks the distance between the float span `[1.1, 3.3]` and 20, and states the answer as 4.625393849793197e+18. That number is the IEEE-754 bit pattern of 16.7 read as a double -- 16.7's bits are the integer 4625393849793196851, which prints as 4.625393849793197e+18. The expectation records a Datum arriving unwrapped; MEOS answers 16.7, which is 20 - 3.3. MEASURED against libmeos built from MobilityDB 40eb373334 at -DALL=ON: the package reports 115 result lines and 0 skipped. Reverting the corrected line alone puts that bit pattern back where MEOS states 16.7, so the expectation is what moves and nothing else. The guard holds the count: it accepts a floor of 115, refuses 116, and refuses the same log with one result line rewritten to SKIP. WHY: a test no job collects is reported nowhere, so no skip count can see it and nothing compares its expectation against MEOS -- which is how an expectation recording a defect survives. The timezone is stated in the job rather than inherited, because the expectations print timestamptz values and the zone is therefore an input to the assertion. This change sits on top of the functions-snapshot refresh, which the build job reaches first. --- .github/workflows/build.yml | 21 +++++++++++++++++++++ example_number_test.go | 2 +- 2 files changed, 22 insertions(+), 1 deletion(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 978de0c..2886177 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -98,3 +98,24 @@ jobs: env: CGO_ENABLED: "0" run: go test ./tools/parity/ + + # The root gomeos package carries the binding's only behavioural tests: + # Example functions whose `// Output:` block is the assertion. They need + # libmeos, which this job already installs, and until now no job collected + # them -- so their expectations were never compared against MEOS at all. + # TZ is stated rather than inherited: the expectations print timestamptz + # values, so the zone is an input to the assertion. + - name: Run the gomeos package tests against the all-families libmeos + env: + PKG_CONFIG_PATH: /usr/local/lib/pkgconfig + LD_LIBRARY_PATH: /usr/local/lib + TZ: UTC + run: go test -v . 2>&1 | tee test.log + + # Refuse the two ways this suite could stop covering the binding while the + # job still reports success: a test that skips, and a suite that shrank. + - name: Refuse a skipped test, and hold the test count + uses: MobilityDB/MEOS-API/.github/actions/check-test-outcome@master + with: + log: test.log + min-tests: "115" diff --git a/example_number_test.go b/example_number_test.go index e28e120..9953f20 100644 --- a/example_number_test.go +++ b/example_number_test.go @@ -265,7 +265,7 @@ func ExampleFloatSpan_Distance() { fmt.Println(distance, err) // Output: //0 - //4.625393849793197e+18 + //16.7 } func ExampleFloatSpan_Intersection() { g_fs := NewFloatSpan("[1.1, 3.3]")