From 276590b6bc2c173c897f6ca1a1a5e0f2d4db5fb3 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 3 Sep 2026 18:50:12 +0200 Subject: [PATCH] Answer a MEOS struct the model gives no class as the handle it already is Nine of the structs the flat layer wraps have no class in the object model, and each correctly has none: `Interval` is PostgreSQL's and absent from the MeosType enum; `SkipList`, `PJ_CONTEXT` and `gsl_rng` are runtime handles MEOS registers in no enum; `AFFINE`, `BOX3D`, `GBOX` and `Match` state their whole layout in scalars; `Rgeo` is the ninth. A method carrying one was deferred, which cost 53 methods -- `Interval` alone accounts for 46. The flat handle IS the type for these, and its semantics are already the ones the ecosystem states for such a struct: the call hands MEOS an address and the memory stays MEOS's. Spelling a value struct here instead is not available in any case -- this package imports no cgo (0 of 116 files against 15 in functions/), so it cannot materialise a C struct, and only the `functions` package can. One rule covers all nine rather than a list of them: a wrapper type the model resolves to no class is handed through as the wrapper's own type, the same way the generated enums already cross. MEASURED: 1309 methods against 1256, deferrals 105 -> 52, and every one of the 52 now reads `has no emitted wrapper` -- so the object layer defers ONLY what the flat generator does not emit, and holds no gap of its own. `go build ./...` over all 12 packages, `go vet ./types` and `gofmt -l types/` (0 files) are clean, and a second generator run reproduces the tree byte for byte. --- tools/objectgen.py | 16 ++++- types/datespan.go | 18 ++++++ types/datespanset.go | 18 ++++++ types/stbox.go | 72 ++++++++++++++++++++++ types/tbox.go | 18 ++++++ types/temporal.go | 126 ++++++++++++++++++++++++++++++++++++++ types/tfloat.go | 27 ++++++++ types/tgeo.go | 18 ++++++ types/tint.go | 27 ++++++++ types/trgeometry.go | 36 +++++++++++ types/trgeometryseqset.go | 9 +++ types/tsequenceset.go | 9 +++ types/tstzset.go | 18 ++++++ types/tstzspan.go | 45 ++++++++++++++ types/tstzspanset.go | 36 +++++++++++ 15 files changed, 492 insertions(+), 1 deletion(-) diff --git a/tools/objectgen.py b/tools/objectgen.py index 4c0c565..be4c661 100644 --- a/tools/objectgen.py +++ b/tools/objectgen.py @@ -205,7 +205,21 @@ def class_of_handle(self, go_type: str) -> str | None: return self.m.class_for_ctype(struct) if struct else None def passthrough(self, go_type: str) -> bool: - return go_type in self.scalars or go_type in ("string", "bool", "unsafe.Pointer") + """Whether this layer hands the wrapper's own type straight through. + + A MEOS struct the model gives no class is one of these. `Interval` is + PostgreSQL's and absent from the MeosType enum, `SkipList`, `PJ_CONTEXT` and + `gsl_rng` are runtime handles MEOS registers in no enum, and `AFFINE`, `BOX3D`, + `GBOX` and `Match` state their whole layout in scalars -- so no class stands for + any of them and none should. The flat handle IS the type, and its semantics are + already the ones MEOS.NET states for a by-value struct: the call hands MEOS an + address and the memory stays MEOS's. Spelling a value struct here instead is not + available anyway -- this package imports no cgo, so it cannot materialise a C + struct, and only the `functions` package can. + """ + return (go_type in self.scalars + or go_type in ("string", "bool", "unsafe.Pointer") + or go_type in self.struct_of) def qualify(self, go_type: str) -> str: """A passthrough type as this package must spell it. diff --git a/types/datespan.go b/types/datespan.go index 44d9b70..9156259 100644 --- a/types/datespan.go +++ b/types/datespan.go @@ -59,6 +59,15 @@ func (x *DateSpan) ToTstzspan() (*Span, error) { return SpanFromPointer(_r0.Pointer()), nil } +// Duration is MEOS datespan_duration. +func (x *DateSpan) Duration() (*functions.Interval, error) { + _r0, _err := functions.DatespanDuration(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return _r0, nil +} + // Lower is MEOS datespan_lower. func (x *DateSpan) Lower() (int32, error) { _r0, _err := functions.DatespanLower(functions.SpanFromPointer(x.Pointer())) @@ -85,3 +94,12 @@ func (x *DateSpan) ShiftScale(shift int, width int, hasshift bool, haswidth bool } return SpanFromPointer(_r0.Pointer()), nil } + +// Bins is MEOS datespan_bins. +func (x *DateSpan) Bins(duration *functions.Interval, torigin int32, count unsafe.Pointer) (*Span, error) { + _r0, _err := functions.DatespanBins(functions.SpanFromPointer(x.Pointer()), duration, torigin, count) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} diff --git a/types/datespanset.go b/types/datespanset.go index ec592d3..b13302f 100644 --- a/types/datespanset.go +++ b/types/datespanset.go @@ -71,6 +71,15 @@ func (x *DateSpanSet) Dates() (*Set, error) { return SetFromPointer(_r0.Pointer()), nil } +// Duration is MEOS datespanset_duration. +func (x *DateSpanSet) Duration(boundspan bool) (*functions.Interval, error) { + _r0, _err := functions.DatespansetDuration(functions.SpanSetFromPointer(x.Pointer()), boundspan) + if _err != nil { + return nil, _err + } + return _r0, nil +} + // EndDate is MEOS datespanset_end_date. func (x *DateSpanSet) EndDate() (int32, error) { _r0, _err := functions.DatespansetEndDate(functions.SpanSetFromPointer(x.Pointer())) @@ -124,3 +133,12 @@ func (x *DateSpanSet) ShiftScale(shift int, width int, hasshift bool, haswidth b } return SpanSetFromPointer(_r0.Pointer()), nil } + +// Bins is MEOS datespanset_bins. +func (x *DateSpanSet) Bins(duration *functions.Interval, torigin int32, count unsafe.Pointer) (*Span, error) { + _r0, _err := functions.DatespansetBins(functions.SpanSetFromPointer(x.Pointer()), duration, torigin, count) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} diff --git a/types/stbox.go b/types/stbox.go index 59ef53b..665de68 100644 --- a/types/stbox.go +++ b/types/stbox.go @@ -95,6 +95,24 @@ func STBoxMake(hasx bool, hasz bool, geodetic bool, srid int32, xmin float64, xm return STBoxFromPointer(_r0.Pointer()), nil } +// ToBox3d is MEOS stbox_to_box3d. +func (x *STBox) ToBox3d() (*functions.Box3D, error) { + _r0, _err := functions.STBOXToBox3d(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// ToGbox is MEOS stbox_to_gbox. +func (x *STBox) ToGbox() (*functions.GBox, error) { + _r0, _err := functions.STBOXToGbox(functions.STBoxFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return _r0, nil +} + // ToGeo is MEOS stbox_to_geo. func (x *STBox) ToGeo() (*TRGeometrySeqSet, error) { _r0, _err := functions.STBOXToGeo(functions.STBoxFromPointer(x.Pointer())) @@ -323,6 +341,15 @@ func (x *STBox) ExpandSpace(d float64) (*STBox, error) { return STBoxFromPointer(_r0.Pointer()), nil } +// ExpandTime is MEOS stbox_expand_time. +func (x *STBox) ExpandTime(interv *functions.Interval) (*STBox, error) { + _r0, _err := functions.STBOXExpandTime(functions.STBoxFromPointer(x.Pointer()), interv) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + // GetSpace is MEOS stbox_get_space. func (x *STBox) GetSpace() (*STBox, error) { _r0, _err := functions.STBOXGetSpace(functions.STBoxFromPointer(x.Pointer())) @@ -350,6 +377,15 @@ func (x *STBox) Round(maxdd int) (*STBox, error) { return STBoxFromPointer(_r0.Pointer()), nil } +// ShiftScaleTime is MEOS stbox_shift_scale_time. +func (x *STBox) ShiftScaleTime(shift *functions.Interval, duration *functions.Interval) (*STBox, error) { + _r0, _err := functions.STBOXShiftScaleTime(functions.STBoxFromPointer(x.Pointer()), shift, duration) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + // SetSRID is MEOS stbox_set_srid. func (x *STBox) SetSRID(srid int32) (*STBox, error) { _r0, _err := functions.STBOXSetSRID(functions.STBoxFromPointer(x.Pointer()), srid) @@ -467,6 +503,24 @@ func STBoxGetSpaceTile(point *TRGeometrySeqSet, xsize float64, ysize float64, zs return STBoxFromPointer(_r0.Pointer()), nil } +// STBoxGetSpaceTimeTile is MEOS stbox_get_space_time_tile. +func STBoxGetSpaceTimeTile(point *TRGeometrySeqSet, t int64, xsize float64, ysize float64, zsize float64, duration *functions.Interval, sorigin *TRGeometrySeqSet, torigin int64) (*STBox, error) { + _r0, _err := functions.STBOXGetSpaceTimeTile(functions.GeomFromPointer(point.Pointer()), t, xsize, ysize, zsize, duration, functions.GeomFromPointer(sorigin.Pointer()), torigin) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// STBoxGetTimeTile is MEOS stbox_get_time_tile. +func STBoxGetTimeTile(t int64, duration *functions.Interval, torigin int64) (*STBox, error) { + _r0, _err := functions.STBOXGetTimeTile(t, duration, torigin) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + // SpaceTiles is MEOS stbox_space_tiles. func (x *STBox) SpaceTiles(xsize float64, ysize float64, zsize float64, sorigin *TRGeometrySeqSet, border_inc bool, count unsafe.Pointer) (*STBox, error) { _r0, _err := functions.STBOXSpaceTiles(functions.STBoxFromPointer(x.Pointer()), xsize, ysize, zsize, functions.GeomFromPointer(sorigin.Pointer()), border_inc, count) @@ -475,3 +529,21 @@ func (x *STBox) SpaceTiles(xsize float64, ysize float64, zsize float64, sorigin } return STBoxFromPointer(_r0.Pointer()), nil } + +// SpaceTimeTiles is MEOS stbox_space_time_tiles. +func (x *STBox) SpaceTimeTiles(xsize float64, ysize float64, zsize float64, duration *functions.Interval, sorigin *TRGeometrySeqSet, torigin int64, border_inc bool, count unsafe.Pointer) (*STBox, error) { + _r0, _err := functions.STBOXSpaceTimeTiles(functions.STBoxFromPointer(x.Pointer()), xsize, ysize, zsize, duration, functions.GeomFromPointer(sorigin.Pointer()), torigin, border_inc, count) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + +// TimeTiles is MEOS stbox_time_tiles. +func (x *STBox) TimeTiles(duration *functions.Interval, torigin int64, border_inc bool, count unsafe.Pointer) (*STBox, error) { + _r0, _err := functions.STBOXTimeTiles(functions.STBoxFromPointer(x.Pointer()), duration, torigin, border_inc, count) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} diff --git a/types/tbox.go b/types/tbox.go index ea24554..deabc18 100644 --- a/types/tbox.go +++ b/types/tbox.go @@ -263,6 +263,15 @@ func (x *TBox) XminInc() (bool, bool, error) { return _value, true, nil } +// ExpandTime is MEOS tbox_expand_time. +func (x *TBox) ExpandTime(interv *functions.Interval) (*TBox, error) { + _r0, _err := functions.TBOXExpandTime(functions.TBoxFromPointer(x.Pointer()), interv) + if _err != nil { + return nil, _err + } + return TBoxFromPointer(_r0.Pointer()), nil +} + // Round is MEOS tbox_round. func (x *TBox) Round(maxdd int) (*TBox, error) { _r0, _err := functions.TBOXRound(functions.TBoxFromPointer(x.Pointer()), maxdd) @@ -272,6 +281,15 @@ func (x *TBox) Round(maxdd int) (*TBox, error) { return TBoxFromPointer(_r0.Pointer()), nil } +// ShiftScaleTime is MEOS tbox_shift_scale_time. +func (x *TBox) ShiftScaleTime(shift *functions.Interval, duration *functions.Interval) (*TBox, error) { + _r0, _err := functions.TBOXShiftScaleTime(functions.TBoxFromPointer(x.Pointer()), shift, duration) + if _err != nil { + return nil, _err + } + return TBoxFromPointer(_r0.Pointer()), nil +} + // Cmp is MEOS tbox_cmp. func (x *TBox) Cmp(box2 *TBox) (int, error) { _r0, _err := functions.TBOXCmp(functions.TBoxFromPointer(x.Pointer()), functions.TBoxFromPointer(box2.Pointer())) diff --git a/types/temporal.go b/types/temporal.go index feb840f..a63336f 100644 --- a/types/temporal.go +++ b/types/temporal.go @@ -88,6 +88,15 @@ func (x *Temporal) ToTstzspan() (*Span, error) { return SpanFromPointer(_r0.Pointer()), nil } +// Duration is MEOS temporal_duration. +func (x *Temporal) Duration(boundspan bool) (*functions.Interval, error) { + _r0, _err := functions.TemporalDuration(functions.TemporalFromPointer(x.Pointer()), boundspan) + if _err != nil { + return nil, _err + } + return _r0, nil +} + // EndInstant is MEOS temporal_end_instant. func (x *Temporal) EndInstant() (*Temporal, error) { _r0, _err := functions.TemporalEndInstant(functions.TemporalFromPointer(x.Pointer())) @@ -214,6 +223,15 @@ func (x *Temporal) NumTimestamps() (int, error) { return _r0, nil } +// SegmDuration is MEOS temporal_segm_duration. +func (x *Temporal) SegmDuration(duration *functions.Interval, atleast bool, strict bool) (*Temporal, error) { + _r0, _err := functions.TemporalSegmDuration(functions.TemporalFromPointer(x.Pointer()), duration, atleast, strict) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + // Segments is MEOS temporal_segments. func (x *Temporal) Segments(count unsafe.Pointer) (unsafe.Pointer, error) { _r0, _err := functions.TemporalSegments(functions.TemporalFromPointer(x.Pointer()), count) @@ -268,6 +286,15 @@ func (x *Temporal) StartTimestamptz() (int64, error) { return _r0, nil } +// Stops is MEOS temporal_stops. +func (x *Temporal) Stops(maxdist float64, minduration *functions.Interval) (*Temporal, error) { + _r0, _err := functions.TemporalStops(functions.TemporalFromPointer(x.Pointer()), maxdist, minduration) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + // Subtype is MEOS temporal_subtype. func (x *Temporal) Subtype() (string, error) { _r0, _err := functions.TemporalSubtype(functions.TemporalFromPointer(x.Pointer())) @@ -334,6 +361,15 @@ func (x *Temporal) Round(maxdd int) (*Temporal, error) { return TemporalFromPointer(_r0.Pointer()), nil } +// ScaleTime is MEOS temporal_scale_time. +func (x *Temporal) ScaleTime(duration *functions.Interval) (*Temporal, error) { + _r0, _err := functions.TemporalScaleTime(functions.TemporalFromPointer(x.Pointer()), duration) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + // SetInterp is MEOS temporal_set_interp. func (x *Temporal) SetInterp(interp functions.Interpolation) (*Temporal, error) { _r0, _err := functions.TemporalSetInterp(functions.TemporalFromPointer(x.Pointer()), interp) @@ -343,6 +379,24 @@ func (x *Temporal) SetInterp(interp functions.Interpolation) (*Temporal, error) return TemporalFromPointer(_r0.Pointer()), nil } +// ShiftScaleTime is MEOS temporal_shift_scale_time. +func (x *Temporal) ShiftScaleTime(shift *functions.Interval, duration *functions.Interval) (*Temporal, error) { + _r0, _err := functions.TemporalShiftScaleTime(functions.TemporalFromPointer(x.Pointer()), shift, duration) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// ShiftTime is MEOS temporal_shift_time. +func (x *Temporal) ShiftTime(shift *functions.Interval) (*Temporal, error) { + _r0, _err := functions.TemporalShiftTime(functions.TemporalFromPointer(x.Pointer()), shift) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + // AsTinstant is MEOS temporal_as_tinstant. func (x *Temporal) AsTinstant() (*Temporal, error) { _r0, _err := functions.TemporalAsTinstant(functions.TemporalFromPointer(x.Pointer())) @@ -370,6 +424,15 @@ func (x *Temporal) AsTsequenceset(interp functions.Interpolation) (*Temporal, er return TemporalFromPointer(_r0.Pointer()), nil } +// AppendTinstant is MEOS temporal_append_tinstant. +func (x *Temporal) AppendTinstant(inst *Temporal, interp functions.Interpolation, maxdist float64, maxt *functions.Interval, expand bool) (*Temporal, error) { + _r0, _err := functions.TemporalAppendTinstant(functions.TemporalFromPointer(x.Pointer()), functions.TInstantFromPointer(inst.Pointer()), interp, maxdist, maxt, expand) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + // AppendTsequence is MEOS temporal_append_tsequence. func (x *Temporal) AppendTsequence(seq *Temporal, expand bool) (*Temporal, error) { _r0, _err := functions.TemporalAppendTsequence(functions.TemporalFromPointer(x.Pointer()), functions.TSequenceFromPointer(seq.Pointer()), expand) @@ -721,6 +784,33 @@ func (x *Temporal) SimplifyMinDist(dist float64) (*Temporal, error) { return TemporalFromPointer(_r0.Pointer()), nil } +// SimplifyMinTdelta is MEOS temporal_simplify_min_tdelta. +func (x *Temporal) SimplifyMinTdelta(mint *functions.Interval) (*Temporal, error) { + _r0, _err := functions.TemporalSimplifyMinTdelta(functions.TemporalFromPointer(x.Pointer()), mint) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Tprecision is MEOS temporal_tprecision. +func (x *Temporal) Tprecision(duration *functions.Interval, origin int64) (*Temporal, error) { + _r0, _err := functions.TemporalTprecision(functions.TemporalFromPointer(x.Pointer()), duration, origin) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + +// Tsample is MEOS temporal_tsample. +func (x *Temporal) Tsample(duration *functions.Interval, origin int64, interp functions.Interpolation) (*Temporal, error) { + _r0, _err := functions.TemporalTsample(functions.TemporalFromPointer(x.Pointer()), duration, origin, interp) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + // DyntimewarpDistance is MEOS temporal_dyntimewarp_distance. func (x *Temporal) DyntimewarpDistance(temp2 *Temporal) (float64, error) { _r0, _err := functions.TemporalDyntimewarpDistance(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer())) @@ -730,6 +820,15 @@ func (x *Temporal) DyntimewarpDistance(temp2 *Temporal) (float64, error) { return _r0, nil } +// DyntimewarpPath is MEOS temporal_dyntimewarp_path. +func (x *Temporal) DyntimewarpPath(temp2 *Temporal, count unsafe.Pointer) (*functions.Match, error) { + _r0, _err := functions.TemporalDyntimewarpPath(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + // FrechetDistance is MEOS temporal_frechet_distance. func (x *Temporal) FrechetDistance(temp2 *Temporal) (float64, error) { _r0, _err := functions.TemporalFrechetDistance(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer())) @@ -739,6 +838,15 @@ func (x *Temporal) FrechetDistance(temp2 *Temporal) (float64, error) { return _r0, nil } +// FrechetPath is MEOS temporal_frechet_path. +func (x *Temporal) FrechetPath(temp2 *Temporal, count unsafe.Pointer) (*functions.Match, error) { + _r0, _err := functions.TemporalFrechetPath(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + // HausdorffDistance is MEOS temporal_hausdorff_distance. func (x *Temporal) HausdorffDistance(temp2 *Temporal) (float64, error) { _r0, _err := functions.TemporalHausdorffDistance(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer())) @@ -774,3 +882,21 @@ func (x *Temporal) ExtKalmanFilter(gate float64, q float64, variance float64, to } return TemporalFromPointer(_r0.Pointer()), nil } + +// TimeBins is MEOS temporal_time_bins. +func (x *Temporal) TimeBins(duration *functions.Interval, origin int64, count unsafe.Pointer) (*Span, error) { + _r0, _err := functions.TemporalTimeBins(functions.TemporalFromPointer(x.Pointer()), duration, origin, count) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// TimeSplit is MEOS temporal_time_split. +func (x *Temporal) TimeSplit(duration *functions.Interval, torigin int64, bins unsafe.Pointer, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TemporalTimeSplit(functions.TemporalFromPointer(x.Pointer()), duration, torigin, bins, count) + if _err != nil { + return nil, _err + } + return _r0, nil +} diff --git a/types/tfloat.go b/types/tfloat.go index 63ac9c4..63ec8be 100644 --- a/types/tfloat.go +++ b/types/tfloat.go @@ -281,6 +281,15 @@ func (x *TFloat) Tan() (*Temporal, error) { return TemporalFromPointer(_r0.Pointer()), nil } +// TimeBoxes is MEOS tfloat_time_boxes. +func (x *TFloat) TimeBoxes(duration *functions.Interval, torigin int64, count unsafe.Pointer) (*TBox, error) { + _r0, _err := functions.TfloatTimeBoxes(functions.TemporalFromPointer(x.Pointer()), duration, torigin, count) + if _err != nil { + return nil, _err + } + return TBoxFromPointer(_r0.Pointer()), nil +} + // ValueBins is MEOS tfloat_value_bins. func (x *TFloat) ValueBins(vsize float64, vorigin float64, count unsafe.Pointer) (*Span, error) { _r0, _err := functions.TfloatValueBins(functions.TemporalFromPointer(x.Pointer()), vsize, vorigin, count) @@ -307,3 +316,21 @@ func (x *TFloat) ValueSplit(size float64, origin float64, bins unsafe.Pointer, c } return _r0, nil } + +// ValueTimeBoxes is MEOS tfloat_value_time_boxes. +func (x *TFloat) ValueTimeBoxes(vsize float64, duration *functions.Interval, vorigin float64, torigin int64, count unsafe.Pointer) (*TBox, error) { + _r0, _err := functions.TfloatValueTimeBoxes(functions.TemporalFromPointer(x.Pointer()), vsize, duration, vorigin, torigin, count) + if _err != nil { + return nil, _err + } + return TBoxFromPointer(_r0.Pointer()), nil +} + +// ValueTimeSplit is MEOS tfloat_value_time_split. +func (x *TFloat) ValueTimeSplit(vsize float64, duration *functions.Interval, vorigin float64, torigin int64, value_bins unsafe.Pointer, time_bins unsafe.Pointer, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TfloatValueTimeSplit(functions.TemporalFromPointer(x.Pointer()), vsize, duration, vorigin, torigin, value_bins, time_bins, count) + if _err != nil { + return nil, _err + } + return _r0, nil +} diff --git a/types/tgeo.go b/types/tgeo.go index 885ca1f..a10450c 100644 --- a/types/tgeo.go +++ b/types/tgeo.go @@ -112,6 +112,15 @@ func (x *TGeo) Values(count unsafe.Pointer) (unsafe.Pointer, error) { return _r0, nil } +// Affine is MEOS tgeo_affine. +func (x *TGeo) Affine(a *functions.AFFINE) (*Temporal, error) { + _r0, _err := functions.TgeoAffine(functions.TemporalFromPointer(x.Pointer()), a) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + // Scale is MEOS tgeo_scale. func (x *TGeo) Scale(scale *TRGeometrySeqSet, sorigin *TRGeometrySeqSet) (*Temporal, error) { _r0, _err := functions.TgeoScale(functions.TemporalFromPointer(x.Pointer()), functions.GeomFromPointer(scale.Pointer()), functions.GeomFromPointer(sorigin.Pointer())) @@ -193,6 +202,15 @@ func (x *TGeo) SpaceBoxes(xsize float64, ysize float64, zsize float64, sorigin * return STBoxFromPointer(_r0.Pointer()), nil } +// SpaceTimeBoxes is MEOS tgeo_space_time_boxes. +func (x *TGeo) SpaceTimeBoxes(xsize float64, ysize float64, zsize float64, duration *functions.Interval, sorigin *TRGeometrySeqSet, torigin int64, bitmatrix bool, border_inc bool, count unsafe.Pointer) (*STBox, error) { + _r0, _err := functions.TgeoSpaceTimeBoxes(functions.TemporalFromPointer(x.Pointer()), xsize, ysize, zsize, duration, functions.GeomFromPointer(sorigin.Pointer()), torigin, bitmatrix, border_inc, count) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + // SplitEachNStboxes is MEOS tgeo_split_each_n_stboxes. func (x *TGeo) SplitEachNStboxes(elem_count int, count unsafe.Pointer) (*STBox, error) { _r0, _err := functions.TgeoSplitEachNStboxes(functions.TemporalFromPointer(x.Pointer()), elem_count, count) diff --git a/types/tint.go b/types/tint.go index 0883ed5..3cf4ff0 100644 --- a/types/tint.go +++ b/types/tint.go @@ -191,6 +191,15 @@ func (x *TInt) MinusValue(i int) (*Temporal, error) { return TemporalFromPointer(_r0.Pointer()), nil } +// TimeBoxes is MEOS tint_time_boxes. +func (x *TInt) TimeBoxes(duration *functions.Interval, torigin int64, count unsafe.Pointer) (*TBox, error) { + _r0, _err := functions.TintTimeBoxes(functions.TemporalFromPointer(x.Pointer()), duration, torigin, count) + if _err != nil { + return nil, _err + } + return TBoxFromPointer(_r0.Pointer()), nil +} + // ValueBins is MEOS tint_value_bins. func (x *TInt) ValueBins(vsize int, vorigin int, count unsafe.Pointer) (*Span, error) { _r0, _err := functions.TintValueBins(functions.TemporalFromPointer(x.Pointer()), vsize, vorigin, count) @@ -217,3 +226,21 @@ func (x *TInt) ValueSplit(vsize int, vorigin int, bins unsafe.Pointer, count uns } return _r0, nil } + +// ValueTimeBoxes is MEOS tint_value_time_boxes. +func (x *TInt) ValueTimeBoxes(vsize int, duration *functions.Interval, vorigin int, torigin int64, count unsafe.Pointer) (*TBox, error) { + _r0, _err := functions.TintValueTimeBoxes(functions.TemporalFromPointer(x.Pointer()), vsize, duration, vorigin, torigin, count) + if _err != nil { + return nil, _err + } + return TBoxFromPointer(_r0.Pointer()), nil +} + +// ValueTimeSplit is MEOS tint_value_time_split. +func (x *TInt) ValueTimeSplit(size int, duration *functions.Interval, vorigin int, torigin int64, value_bins unsafe.Pointer, time_bins unsafe.Pointer, count unsafe.Pointer) (unsafe.Pointer, error) { + _r0, _err := functions.TintValueTimeSplit(functions.TemporalFromPointer(x.Pointer()), size, duration, vorigin, torigin, value_bins, time_bins, count) + if _err != nil { + return nil, _err + } + return _r0, nil +} diff --git a/types/trgeometry.go b/types/trgeometry.go index 0ac0392..e3aacc4 100644 --- a/types/trgeometry.go +++ b/types/trgeometry.go @@ -296,6 +296,15 @@ func (x *TRGeometry) SpaceBoxes(xsize float64, ysize float64, zsize float64, sor return STBoxFromPointer(_r0.Pointer()), nil } +// SpaceTimeBoxes is MEOS trgeometry_space_time_boxes. +func (x *TRGeometry) SpaceTimeBoxes(xsize float64, ysize float64, zsize float64, duration *functions.Interval, sorigin *TRGeometrySeqSet, torigin int64, bitmatrix bool, border_inc bool, count unsafe.Pointer) (*STBox, error) { + _r0, _err := functions.TrgeometrySpaceTimeBoxes(functions.TemporalFromPointer(x.Pointer()), xsize, ysize, zsize, duration, functions.GeomFromPointer(sorigin.Pointer()), torigin, bitmatrix, border_inc, count) + if _err != nil { + return nil, _err + } + return STBoxFromPointer(_r0.Pointer()), nil +} + // Stboxes is MEOS trgeometry_stboxes. func (x *TRGeometry) Stboxes(count unsafe.Pointer) (*STBox, error) { _r0, _err := functions.TrgeometryStboxes(functions.TemporalFromPointer(x.Pointer()), count) @@ -350,6 +359,24 @@ func (x *TRGeometry) DyntimewarpDistance(temp2 *Temporal) (float64, error) { return _r0, nil } +// FrechetPath is MEOS trgeometry_frechet_path. +func (x *TRGeometry) FrechetPath(temp2 *Temporal, count unsafe.Pointer) (*functions.Match, error) { + _r0, _err := functions.TrgeometryFrechetPath(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// DyntimewarpPath is MEOS trgeometry_dyntimewarp_path. +func (x *TRGeometry) DyntimewarpPath(temp2 *Temporal, count unsafe.Pointer) (*functions.Match, error) { + _r0, _err := functions.TrgeometryDyntimewarpPath(functions.TemporalFromPointer(x.Pointer()), functions.TemporalFromPointer(temp2.Pointer()), count) + if _err != nil { + return nil, _err + } + return _r0, nil +} + // Length is MEOS trgeometry_length. func (x *TRGeometry) Length() (float64, error) { _r0, _err := functions.TrgeometryLength(functions.TemporalFromPointer(x.Pointer())) @@ -395,6 +422,15 @@ func (x *TRGeometry) Twcentroid() (*TRGeometrySeqSet, error) { return TRGeometrySeqSetFromPointer(_r0.Pointer()), nil } +// AppendTinstant is MEOS trgeometry_append_tinstant. +func (x *TRGeometry) AppendTinstant(inst *Temporal, interp functions.Interpolation, maxdist float64, maxt *functions.Interval, expand bool) (*Temporal, error) { + _r0, _err := functions.TrgeometryAppendTinstant(functions.TemporalFromPointer(x.Pointer()), functions.TInstantFromPointer(inst.Pointer()), interp, maxdist, maxt, expand) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} + // AppendTsequence is MEOS trgeometry_append_tsequence. func (x *TRGeometry) AppendTsequence(seq *Temporal, expand bool) (*Temporal, error) { _r0, _err := functions.TrgeometryAppendTsequence(functions.TemporalFromPointer(x.Pointer()), functions.TSequenceFromPointer(seq.Pointer()), expand) diff --git a/types/trgeometryseqset.go b/types/trgeometryseqset.go index 62a8870..52d034f 100644 --- a/types/trgeometryseqset.go +++ b/types/trgeometryseqset.go @@ -31,3 +31,12 @@ func (x *TRGeometrySeqSet) Make(sequences unsafe.Pointer, count int, normalize b } return TemporalFromPointer(_r0.Pointer()), nil } + +// MakeGaps is MEOS trgeometryseqset_make_gaps. +func (x *TRGeometrySeqSet) MakeGaps(instants unsafe.Pointer, count int, interp functions.Interpolation, maxt *functions.Interval, maxdist float64) (*Temporal, error) { + _r0, _err := functions.TrgeometryseqsetMakeGaps(functions.GeomFromPointer(x.Pointer()), instants, count, interp, maxt, maxdist) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tsequenceset.go b/types/tsequenceset.go index f84319f..876c91f 100644 --- a/types/tsequenceset.go +++ b/types/tsequenceset.go @@ -31,3 +31,12 @@ func TSequenceSetMake(sequences unsafe.Pointer, count int, normalize bool) (*Tem } return TemporalFromPointer(_r0.Pointer()), nil } + +// TSequenceSetMakeGaps is MEOS tsequenceset_make_gaps. +func TSequenceSetMakeGaps(instants unsafe.Pointer, count int, interp functions.Interpolation, maxt *functions.Interval, maxdist float64) (*Temporal, error) { + _r0, _err := functions.TsequencesetMakeGaps(instants, count, interp, maxt, maxdist) + if _err != nil { + return nil, _err + } + return TemporalFromPointer(_r0.Pointer()), nil +} diff --git a/types/tstzset.go b/types/tstzset.go index 8264052..c278030 100644 --- a/types/tstzset.go +++ b/types/tstzset.go @@ -98,6 +98,24 @@ func (x *TsTzSet) Values(count unsafe.Pointer) (unsafe.Pointer, error) { return _r0, nil } +// ShiftScale is MEOS tstzset_shift_scale. +func (x *TsTzSet) ShiftScale(shift *functions.Interval, duration *functions.Interval) (*Set, error) { + _r0, _err := functions.TstzsetShiftScale(functions.SetFromPointer(x.Pointer()), shift, duration) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + +// Tprecision is MEOS tstzset_tprecision. +func (x *TsTzSet) Tprecision(duration *functions.Interval, torigin int64) (*Set, error) { + _r0, _err := functions.TstzsetTprecision(functions.SetFromPointer(x.Pointer()), duration, torigin) + if _err != nil { + return nil, _err + } + return SetFromPointer(_r0.Pointer()), nil +} + // ToStbox is MEOS tstzset_to_stbox. func (x *TsTzSet) ToStbox() (*STBox, error) { _r0, _err := functions.TstzsetToSTBOX(functions.SetFromPointer(x.Pointer())) diff --git a/types/tstzspan.go b/types/tstzspan.go index 6924128..5854a0c 100644 --- a/types/tstzspan.go +++ b/types/tstzspan.go @@ -59,6 +59,15 @@ func (x *TsTzSpan) ToDatespan() (*Span, error) { return SpanFromPointer(_r0.Pointer()), nil } +// Duration is MEOS tstzspan_duration. +func (x *TsTzSpan) Duration() (*functions.Interval, error) { + _r0, _err := functions.TstzspanDuration(functions.SpanFromPointer(x.Pointer())) + if _err != nil { + return nil, _err + } + return _r0, nil +} + // Lower is MEOS tstzspan_lower. func (x *TsTzSpan) Lower() (int64, error) { _r0, _err := functions.TstzspanLower(functions.SpanFromPointer(x.Pointer())) @@ -77,6 +86,42 @@ func (x *TsTzSpan) Upper() (int64, error) { return _r0, nil } +// Expand is MEOS tstzspan_expand. +func (x *TsTzSpan) Expand(interv *functions.Interval) (*Span, error) { + _r0, _err := functions.TstzspanExpand(functions.SpanFromPointer(x.Pointer()), interv) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// ShiftScale is MEOS tstzspan_shift_scale. +func (x *TsTzSpan) ShiftScale(shift *functions.Interval, duration *functions.Interval) (*Span, error) { + _r0, _err := functions.TstzspanShiftScale(functions.SpanFromPointer(x.Pointer()), shift, duration) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Tprecision is MEOS tstzspan_tprecision. +func (x *TsTzSpan) Tprecision(duration *functions.Interval, torigin int64) (*Span, error) { + _r0, _err := functions.TstzspanTprecision(functions.SpanFromPointer(x.Pointer()), duration, torigin) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + +// Bins is MEOS tstzspan_bins. +func (x *TsTzSpan) Bins(duration *functions.Interval, origin int64, count unsafe.Pointer) (*Span, error) { + _r0, _err := functions.TstzspanBins(functions.SpanFromPointer(x.Pointer()), duration, origin, count) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + // ToStbox is MEOS tstzspan_to_stbox. func (x *TsTzSpan) ToStbox() (*STBox, error) { _r0, _err := functions.TstzspanToSTBOX(functions.SpanFromPointer(x.Pointer())) diff --git a/types/tstzspanset.go b/types/tstzspanset.go index 696b7bf..d24baf7 100644 --- a/types/tstzspanset.go +++ b/types/tstzspanset.go @@ -50,6 +50,15 @@ func (x *TsTzSpanSet) ToDatespanset() (*SpanSet, error) { return SpanSetFromPointer(_r0.Pointer()), nil } +// Duration is MEOS tstzspanset_duration. +func (x *TsTzSpanSet) Duration(boundspan bool) (*functions.Interval, error) { + _r0, _err := functions.TstzspansetDuration(functions.SpanSetFromPointer(x.Pointer()), boundspan) + if _err != nil { + return nil, _err + } + return _r0, nil +} + // EndTimestamptz is MEOS tstzspanset_end_timestamptz. func (x *TsTzSpanSet) EndTimestamptz() (int64, error) { _r0, _err := functions.TstzspansetEndTimestamptz(functions.SpanSetFromPointer(x.Pointer())) @@ -116,6 +125,33 @@ func (x *TsTzSpanSet) Upper() (int64, error) { return _r0, nil } +// ShiftScale is MEOS tstzspanset_shift_scale. +func (x *TsTzSpanSet) ShiftScale(shift *functions.Interval, duration *functions.Interval) (*SpanSet, error) { + _r0, _err := functions.TstzspansetShiftScale(functions.SpanSetFromPointer(x.Pointer()), shift, duration) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// Tprecision is MEOS tstzspanset_tprecision. +func (x *TsTzSpanSet) Tprecision(duration *functions.Interval, torigin int64) (*SpanSet, error) { + _r0, _err := functions.TstzspansetTprecision(functions.SpanSetFromPointer(x.Pointer()), duration, torigin) + if _err != nil { + return nil, _err + } + return SpanSetFromPointer(_r0.Pointer()), nil +} + +// Bins is MEOS tstzspanset_bins. +func (x *TsTzSpanSet) Bins(duration *functions.Interval, torigin int64, count unsafe.Pointer) (*Span, error) { + _r0, _err := functions.TstzspansetBins(functions.SpanSetFromPointer(x.Pointer()), duration, torigin, count) + if _err != nil { + return nil, _err + } + return SpanFromPointer(_r0.Pointer()), nil +} + // ToStbox is MEOS tstzspanset_to_stbox. func (x *TsTzSpanSet) ToStbox() (*STBox, error) { _r0, _err := functions.TstzspansetToSTBOX(functions.SpanSetFromPointer(x.Pointer()))