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()))