From eb01fb4c729230ae0043d40731de47e06e109cfa Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 19 Nov 2026 22:40:46 +0100 Subject: [PATCH] Read the class of an aggregate off the SQL type of its values An aggregate several transitions serve under one name, one per type of its values, as tMinAgg is tint_tmin_transfn over tint and tfloat_tmin_transfn over tfloat, is a static method of each value's class. #aggregate_class of tools/objectgen.py reads that class off the catalog as #aggregateClass of MEOS.js's codegen/ObjectGenerator.ts does: the leaf of the lattice whose prefix is the SQL type of the aggregate's values (args[0] of the aggregate, tint naming TInt), and otherwise the class of the C type the transition takes the values as. Each method keeps the aggregate's one name and takes the values as its class's own: TInt.TMinAgg(TInt[] values) and TFloat.TSum(TFloat[] values). A struct argument passed by value, the interval of the window aggregates and of appendInstantAgg, is laid out once for every call of the transition, as #call_body lays one out for its call, so TInt.WMin(TInt[] values, Interval interv) and the other window aggregates are methods too; no aggregate is left in GAP-LEDGER.md. MEOS.NET.Tests/AggregateOverloadTests.cs sums two temporal floats and takes the minimum of a temporal integer. Why: an aggregate whose transitions all take a Temporal had no method, since the class of that C type is Temporal for every one of them, and an aggregate whose transition takes an interval had none either. Measured: over the catalog of MobilityDB master d2a7ca45ca, dotnet build reports 0 warnings and 0 errors, and dotnet test passes 123 of 123 with none skipped. --- GAP-LEDGER.md | 22 +-- MEOS.NET.Tests/AggregateOverloadTests.cs | 50 ++++++ MEOS.NET/Types/TBigInt.g.cs | 197 +++++++++++++++++++++ MEOS.NET/Types/TBool.g.cs | 75 ++++++++ MEOS.NET/Types/TCBuffer.g.cs | 73 ++++++++ MEOS.NET/Types/TFloat.g.cs | 208 +++++++++++++++++++++++ MEOS.NET/Types/TGeogPoint.g.cs | 84 +++++++++ MEOS.NET/Types/TGeography.g.cs | 73 ++++++++ MEOS.NET/Types/TGeomPoint.g.cs | 95 +++++++++++ MEOS.NET/Types/TGeometry.g.cs | 73 ++++++++ MEOS.NET/Types/TH3Index.g.cs | 73 ++++++++ MEOS.NET/Types/TInt.g.cs | 197 +++++++++++++++++++++ MEOS.NET/Types/TJsonb.g.cs | 73 ++++++++ MEOS.NET/Types/TNPoint.g.cs | 84 +++++++++ MEOS.NET/Types/TPCPatch.g.cs | 95 +++++++++++ MEOS.NET/Types/TPCPoint.g.cs | 73 ++++++++ MEOS.NET/Types/TPose.g.cs | 73 ++++++++ MEOS.NET/Types/TPoseChain.g.cs | 73 ++++++++ MEOS.NET/Types/TQuadbin.g.cs | 73 ++++++++ MEOS.NET/Types/TRGeometry.g.cs | 73 ++++++++ MEOS.NET/Types/TS2Cell.g.cs | 73 ++++++++ MEOS.NET/Types/TText.g.cs | 75 ++++++++ MEOS.NET/Types/Temporal.g.cs | 99 ----------- tools/objectgen.py | 48 +++++- 24 files changed, 2008 insertions(+), 124 deletions(-) create mode 100644 MEOS.NET.Tests/AggregateOverloadTests.cs diff --git a/GAP-LEDGER.md b/GAP-LEDGER.md index b605345..4d06b89 100644 --- a/GAP-LEDGER.md +++ b/GAP-LEDGER.md @@ -10,7 +10,7 @@ A kind with no rows is a site the generators watch and that nothing reached in this run. It prints so that an empty class reads as a measurement rather than as a class nobody looked at. -Generated from `meos-idl.json` at MobilityDB `eb4454101301017dc26c4ec00ca1ac7a72f53910` by `tools/codegen.py` +Generated from `meos-idl.json` at MobilityDB `d2a7ca45caf9c4c93b9540326e888a8c1fb48427` by `tools/codegen.py` and `tools/objectgen.py`. Do not edit. @@ -4578,19 +4578,11 @@ An operator takes the name and parameter types of a member of an ancestor, a sec None in this run. -### aggregate served by several transitions — 7 +### aggregate served by several transitions — 0 Several transition functions serve one aggregate name over values of the class, and nothing in the values tells them apart. -| class | member | what is missing | -| --- | --- | --- | -| Temporal | tCentroid | tpoint_tcentroid_transfn, tnpoint_tcentroid_transfn | -| Temporal | tMaxAgg | tint_tmax_transfn, tbigint_tmax_transfn, tfloat_tmax_transfn, ttext_tmax_transfn | -| Temporal | tMinAgg | tint_tmin_transfn, tbigint_tmin_transfn, tfloat_tmin_transfn, ttext_tmin_transfn | -| Temporal | tSum | tint_tsum_transfn, tbigint_tsum_transfn, tfloat_tsum_transfn | -| Temporal | wMax | tint_wmax_transfn, tbigint_wmax_transfn, tfloat_wmax_transfn | -| Temporal | wMin | tint_wmin_transfn, tbigint_wmin_transfn, tfloat_wmin_transfn | -| Temporal | wSum | tint_wsum_transfn, tbigint_wsum_transfn, tfloat_wsum_transfn | +None in this run. ### aggregate state not threadable — 0 @@ -4598,14 +4590,10 @@ The transition and the final function of the aggregate do not pass one state poi None in this run. -### aggregate argument or result needs marshalling — 3 +### aggregate argument or result needs marshalling — 0 An argument of the transition or the result of the final function has no rule of this generator. -| class | member | what is missing | -| --- | --- | --- | -| Temporal | appendInstantAgg | temporal_app_tinst_transfn / temporal_append_finalfn | -| Temporal | wAvgAgg | tnumber_wavg_transfn / tnumber_tavg_finalfn | -| Temporal | wCount | temporal_wcount_transfn / temporal_tagg_finalfn | +None in this run. diff --git a/MEOS.NET.Tests/AggregateOverloadTests.cs b/MEOS.NET.Tests/AggregateOverloadTests.cs new file mode 100644 index 0000000..e99ee47 --- /dev/null +++ b/MEOS.NET.Tests/AggregateOverloadTests.cs @@ -0,0 +1,50 @@ +using MEOS.NET.Types; + +namespace MEOS.NET.Tests +{ + /// + /// An aggregate several transitions serve under one name, one per type of + /// its values (tsum is tint_tsum_transfn over tint and tfloat_tsum_transfn + /// over tfloat), is a static method of each value's class: the catalog names + /// that class by the SQL type of the aggregate's values, the prefix of its + /// leaf of the lattice. Each answer is the one MobilityDB's + /// 040_temporal_aggfuncs test states for the same values, as + /// AggregateTests states the raster aggregates'. + /// + [TestClass] + public class AggregateOverloadTests : MeosTest + { + private static TFloat Float(string text) => (TFloat)TFloat.FromText(text)!; + private static TInt Int(string text) => (TInt)TInt.FromText(text)!; + + [TestMethod] + public void TheSumOfTwoTemporalFloatsAddsThemWhereTheyOverlap() + { + Temporal sum = TFloat.TSum(new[] + { + Float("[1@2001-01-01, 2@2001-01-03, 1@2001-01-05, 2@2001-01-07]"), + Float("[3@2001-01-02, 4@2001-01-06]"), + })!; + + Temporal expected = Float("{[1@2001-01-01, 1.5@2001-01-02), " + + "[4.5@2001-01-02, 5.25@2001-01-03, 4.75@2001-01-05, 5.5@2001-01-06], " + + "(1.5@2001-01-06, 2@2001-01-07]}"); + Assert.AreEqual(expected.AsText(15), sum.AsText(15)); + } + + [TestMethod] + public void TheMinimumOfOneTemporalIntegerIsThatValue() + { + Temporal min = TInt.TMinAgg(new[] { Int("1@2001-01-01") })!; + + Assert.AreEqual(Int("{1@2001-01-01}").AsText(15), min.AsText(15)); + } + + [TestMethod] + public void AnAggregateOverNoValuesIsNull() + { + Assert.IsNull(TInt.TMinAgg(Array.Empty())); + Assert.IsNull(TFloat.TSum(Array.Empty())); + } + } +} diff --git a/MEOS.NET/Types/TBigInt.g.cs b/MEOS.NET/Types/TBigInt.g.cs index 3ff7427..46cc821 100644 --- a/MEOS.NET/Types/TBigInt.g.cs +++ b/MEOS.NET/Types/TBigInt.g.cs @@ -451,6 +451,37 @@ public long Value() public long[] Values() => Meos.TbigintValues(this.Ptr); + public static Temporal? AppendInstantAgg(TBigInt[] values, string interp, double maxdist, Interval maxt) + { + IntPtr _maxt = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(maxt, _maxt, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTinstTransfn(_state, _v.Ptr, Meos.InterptypeFromString(interp), maxdist, _maxt); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_maxt); + } + } + + public static Temporal? AppendSequenceAgg(TBigInt[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTseqTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + public static Temporal? FromBaseTemp(long i, Temporal temp) => MEOSFactory.WrapTemporal(Meos.TbigintFromBaseTemp(i, temp.Ptr)); @@ -460,5 +491,171 @@ public long[] Values() public static Temporal? FromText(string str) => MEOSFactory.WrapTemporal(Meos.TbigintIn(str)); + public static Temporal? MergeAgg(TBigInt[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalMergeTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TAvg(TBigInt[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TnumberTavgTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TnumberTavgFinalfn(_state)); + } + + public static Temporal? TCount(TBigInt[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TMaxAgg(TBigInt[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TbigintTmaxTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TMinAgg(TBigInt[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TbigintTminTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TSum(TBigInt[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TbigintTsumTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? WAvgAgg(TBigInt[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TnumberWavgTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TnumberTavgFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + + public static Temporal? WCount(TBigInt[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalWcountTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + + public static Temporal? WMax(TBigInt[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TbigintWmaxTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + + public static Temporal? WMin(TBigInt[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TbigintWminTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + + public static Temporal? WSum(TBigInt[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TbigintWsumTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + } } diff --git a/MEOS.NET/Types/TBool.g.cs b/MEOS.NET/Types/TBool.g.cs index d68b6c5..20998e7 100644 --- a/MEOS.NET/Types/TBool.g.cs +++ b/MEOS.NET/Types/TBool.g.cs @@ -193,6 +193,37 @@ public bool[] Values() public SpanSet? WhenTrue() => MEOSFactory.WrapSpanSet(Meos.TboolWhenTrue(this.Ptr)); + public static Temporal? AppendInstantAgg(TBool[] values, string interp, double maxdist, Interval maxt) + { + IntPtr _maxt = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(maxt, _maxt, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTinstTransfn(_state, _v.Ptr, Meos.InterptypeFromString(interp), maxdist, _maxt); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_maxt); + } + } + + public static Temporal? AppendSequenceAgg(TBool[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTseqTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + public static Temporal? FromBaseTemp(bool b, Temporal temp) => MEOSFactory.WrapTemporal(Meos.TboolFromBaseTemp(b, temp.Ptr)); @@ -202,5 +233,49 @@ public bool[] Values() public static Temporal? FromText(string str) => MEOSFactory.WrapTemporal(Meos.TboolIn(str)); + public static Temporal? MergeAgg(TBool[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalMergeTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TAndAgg(TBool[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TboolTandTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TCount(TBool[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TOrAgg(TBool[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TboolTorTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + } } diff --git a/MEOS.NET/Types/TCBuffer.g.cs b/MEOS.NET/Types/TCBuffer.g.cs index 7affbdb..4aad48d 100644 --- a/MEOS.NET/Types/TCBuffer.g.cs +++ b/MEOS.NET/Types/TCBuffer.g.cs @@ -430,6 +430,37 @@ public bool Same(TCBuffer temp2) public CBuffer?[] Values() => MEOSFactory.WrapCBufferArray(Meos.TcbufferValues(this.Ptr)); + public static Temporal? AppendInstantAgg(TCBuffer[] values, string interp, double maxdist, Interval maxt) + { + IntPtr _maxt = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(maxt, _maxt, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTinstTransfn(_state, _v.Ptr, Meos.InterptypeFromString(interp), maxdist, _maxt); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_maxt); + } + } + + public static Temporal? AppendSequenceAgg(TCBuffer[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTseqTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + public static Temporal? FromBaseTemp(CBuffer cb, Temporal temp) => MEOSFactory.WrapTemporal(Meos.TcbufferFromBaseTemp(cb.Ptr, temp.Ptr)); @@ -448,5 +479,47 @@ public bool Same(TCBuffer temp2) public static Temporal? FromText(string str) => MEOSFactory.WrapTemporal(Meos.TcbufferIn(str)); + public static Temporal? MergeAgg(TCBuffer[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalMergeTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TCount(TCBuffer[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? WCount(TCBuffer[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalWcountTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + } } diff --git a/MEOS.NET/Types/TFloat.g.cs b/MEOS.NET/Types/TFloat.g.cs index 9991d9e..eec1625 100644 --- a/MEOS.NET/Types/TFloat.g.cs +++ b/MEOS.NET/Types/TFloat.g.cs @@ -478,6 +478,37 @@ public double Value() public double[] Values() => Meos.TfloatValues(this.Ptr); + public static Temporal? AppendInstantAgg(TFloat[] values, string interp, double maxdist, Interval maxt) + { + IntPtr _maxt = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(maxt, _maxt, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTinstTransfn(_state, _v.Ptr, Meos.InterptypeFromString(interp), maxdist, _maxt); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_maxt); + } + } + + public static Temporal? AppendSequenceAgg(TFloat[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTseqTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + public static Temporal? FromBaseTemp(double d, Temporal temp) => MEOSFactory.WrapTemporal(Meos.TfloatFromBaseTemp(d, temp.Ptr)); @@ -487,5 +518,182 @@ public double[] Values() public static Temporal? FromText(string str) => MEOSFactory.WrapTemporal(Meos.TfloatIn(str)); + public static Temporal? MergeAgg(TFloat[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalMergeTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? ReachabilityFilterAgg(TFloat[] values, double maxspeed) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalReachabilityFilterTransfn(_state, _v.Ptr, maxspeed); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalReachabilityFilterFinalfn(_state)); + } + + public static Temporal? TAvg(TFloat[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TnumberTavgTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TnumberTavgFinalfn(_state)); + } + + public static Temporal? TCount(TFloat[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TMaxAgg(TFloat[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TfloatTmaxTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TMinAgg(TFloat[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TfloatTminTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TSum(TFloat[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TfloatTsumTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? WAvgAgg(TFloat[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TnumberWavgTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TnumberTavgFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + + public static Temporal? WCount(TFloat[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalWcountTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + + public static Temporal? WMax(TFloat[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TfloatWmaxTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + + public static Temporal? WMin(TFloat[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TfloatWminTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + + public static Temporal? WSum(TFloat[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TfloatWsumTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + } } diff --git a/MEOS.NET/Types/TGeogPoint.g.cs b/MEOS.NET/Types/TGeogPoint.g.cs index 4b872de..d1cb1ee 100644 --- a/MEOS.NET/Types/TGeogPoint.g.cs +++ b/MEOS.NET/Types/TGeogPoint.g.cs @@ -207,6 +207,37 @@ public bool Same(TGeogPoint temp2) public Temporal? ToTs2cell(int level, bool border_inc) => MEOSFactory.WrapTemporal(Meos.TgeogpointToTs2cell(this.Ptr, level, border_inc)); + public static Temporal? AppendInstantAgg(TGeogPoint[] values, string interp, double maxdist, Interval maxt) + { + IntPtr _maxt = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(maxt, _maxt, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTinstTransfn(_state, _v.Ptr, Meos.InterptypeFromString(interp), maxdist, _maxt); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_maxt); + } + } + + public static Temporal? AppendSequenceAgg(TGeogPoint[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTseqTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + public static Temporal? FromEWKB(byte[] wkb) => Temporal.FromWKB(wkb); @@ -222,5 +253,58 @@ public bool Same(TGeogPoint temp2) public static Temporal? FromText(string str) => MEOSFactory.WrapTemporal(Meos.TgeogpointIn(str)); + public static Temporal? MergeAgg(TGeogPoint[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalMergeTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? ReachabilityFilterAgg(TGeogPoint[] values, double maxspeed) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalReachabilityFilterTransfn(_state, _v.Ptr, maxspeed); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalReachabilityFilterFinalfn(_state)); + } + + public static Temporal? TCount(TGeogPoint[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? WCount(TGeogPoint[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalWcountTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + } } diff --git a/MEOS.NET/Types/TGeography.g.cs b/MEOS.NET/Types/TGeography.g.cs index 957d8e4..4d8cc73 100644 --- a/MEOS.NET/Types/TGeography.g.cs +++ b/MEOS.NET/Types/TGeography.g.cs @@ -171,6 +171,37 @@ public bool Same(TGeography temp2) public Temporal? ToTgeometry() => MEOSFactory.WrapTemporal(Meos.TgeographyToTgeometry(this.Ptr)); + public static Temporal? AppendInstantAgg(TGeography[] values, string interp, double maxdist, Interval maxt) + { + IntPtr _maxt = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(maxt, _maxt, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTinstTransfn(_state, _v.Ptr, Meos.InterptypeFromString(interp), maxdist, _maxt); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_maxt); + } + } + + public static Temporal? AppendSequenceAgg(TGeography[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTseqTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + public static Temporal? FromEWKB(byte[] wkb) => Temporal.FromWKB(wkb); @@ -186,5 +217,47 @@ public bool Same(TGeography temp2) public static Temporal? FromText(string str) => MEOSFactory.WrapTemporal(Meos.TgeographyIn(str)); + public static Temporal? MergeAgg(TGeography[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalMergeTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TCount(TGeography[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? WCount(TGeography[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalWcountTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + } } diff --git a/MEOS.NET/Types/TGeomPoint.g.cs b/MEOS.NET/Types/TGeomPoint.g.cs index 1947b0e..250c364 100644 --- a/MEOS.NET/Types/TGeomPoint.g.cs +++ b/MEOS.NET/Types/TGeomPoint.g.cs @@ -252,6 +252,37 @@ public bool Same(TGeomPoint temp2) public Temporal? ToTs2cell(int level, bool border_inc) => MEOSFactory.WrapTemporal(Meos.TgeompointToTs2cell(this.Ptr, level, border_inc)); + public static Temporal? AppendInstantAgg(TGeomPoint[] values, string interp, double maxdist, Interval maxt) + { + IntPtr _maxt = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(maxt, _maxt, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTinstTransfn(_state, _v.Ptr, Meos.InterptypeFromString(interp), maxdist, _maxt); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_maxt); + } + } + + public static Temporal? AppendSequenceAgg(TGeomPoint[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTseqTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + public static Temporal? FromEWKB(byte[] wkb) => Temporal.FromWKB(wkb); @@ -267,5 +298,69 @@ public bool Same(TGeomPoint temp2) public static Temporal? FromText(string str) => MEOSFactory.WrapTemporal(Meos.TgeompointIn(str)); + public static Temporal? MergeAgg(TGeomPoint[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalMergeTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? ReachabilityFilterAgg(TGeomPoint[] values, double maxspeed) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalReachabilityFilterTransfn(_state, _v.Ptr, maxspeed); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalReachabilityFilterFinalfn(_state)); + } + + public static Temporal? TCentroid(TGeomPoint[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TpointTcentroidTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TpointTcentroidFinalfn(_state)); + } + + public static Temporal? TCount(TGeomPoint[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? WCount(TGeomPoint[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalWcountTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + } } diff --git a/MEOS.NET/Types/TGeometry.g.cs b/MEOS.NET/Types/TGeometry.g.cs index 7a31796..5078fae 100644 --- a/MEOS.NET/Types/TGeometry.g.cs +++ b/MEOS.NET/Types/TGeometry.g.cs @@ -261,6 +261,37 @@ public bool Same(TGeometry temp2) public Temporal? Ttouches(TGeometry temp2) => MEOSFactory.WrapTemporal(Meos.TtouchesTgeoTgeo(this.Ptr, temp2.Ptr)); + public static Temporal? AppendInstantAgg(TGeometry[] values, string interp, double maxdist, Interval maxt) + { + IntPtr _maxt = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(maxt, _maxt, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTinstTransfn(_state, _v.Ptr, Meos.InterptypeFromString(interp), maxdist, _maxt); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_maxt); + } + } + + public static Temporal? AppendSequenceAgg(TGeometry[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTseqTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + public static Temporal? FromEWKB(byte[] wkb) => Temporal.FromWKB(wkb); @@ -276,5 +307,47 @@ public bool Same(TGeometry temp2) public static Temporal? FromText(string str) => MEOSFactory.WrapTemporal(Meos.TgeometryIn(str)); + public static Temporal? MergeAgg(TGeometry[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalMergeTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TCount(TGeometry[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? WCount(TGeometry[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalWcountTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + } } diff --git a/MEOS.NET/Types/TH3Index.g.cs b/MEOS.NET/Types/TH3Index.g.cs index 885f2b1..125d24a 100644 --- a/MEOS.NET/Types/TH3Index.g.cs +++ b/MEOS.NET/Types/TH3Index.g.cs @@ -259,6 +259,37 @@ public H3Index[] Values() public Temporal? VertexToLatlng() => MEOSFactory.WrapTemporal(Meos.Th3indexVertexToLatlng(this.Ptr)); + public static Temporal? AppendInstantAgg(TH3Index[] values, string interp, double maxdist, Interval maxt) + { + IntPtr _maxt = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(maxt, _maxt, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTinstTransfn(_state, _v.Ptr, Meos.InterptypeFromString(interp), maxdist, _maxt); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_maxt); + } + } + + public static Temporal? AppendSequenceAgg(TH3Index[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTseqTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + public static Temporal? FromBaseTemp(H3Index value, Temporal temp) => MEOSFactory.WrapTemporal(Meos.Th3indexFromBaseTemp(value.value, temp.Ptr)); @@ -277,5 +308,47 @@ public H3Index[] Values() public static Temporal? FromText(string str) => MEOSFactory.WrapTemporal(Meos.Th3indexIn(str)); + public static Temporal? MergeAgg(TH3Index[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalMergeTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TCount(TH3Index[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? WCount(TH3Index[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalWcountTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + } } diff --git a/MEOS.NET/Types/TInt.g.cs b/MEOS.NET/Types/TInt.g.cs index f2f94c6..4ebb153 100644 --- a/MEOS.NET/Types/TInt.g.cs +++ b/MEOS.NET/Types/TInt.g.cs @@ -445,6 +445,37 @@ public int Value() public int[] Values() => Meos.TintValues(this.Ptr); + public static Temporal? AppendInstantAgg(TInt[] values, string interp, double maxdist, Interval maxt) + { + IntPtr _maxt = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(maxt, _maxt, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTinstTransfn(_state, _v.Ptr, Meos.InterptypeFromString(interp), maxdist, _maxt); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_maxt); + } + } + + public static Temporal? AppendSequenceAgg(TInt[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTseqTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + public static Temporal? FromBaseTemp(int i, Temporal temp) => MEOSFactory.WrapTemporal(Meos.TintFromBaseTemp(i, temp.Ptr)); @@ -454,5 +485,171 @@ public int[] Values() public static Temporal? FromText(string str) => MEOSFactory.WrapTemporal(Meos.TintIn(str)); + public static Temporal? MergeAgg(TInt[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalMergeTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TAvg(TInt[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TnumberTavgTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TnumberTavgFinalfn(_state)); + } + + public static Temporal? TCount(TInt[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TMaxAgg(TInt[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TintTmaxTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TMinAgg(TInt[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TintTminTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TSum(TInt[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TintTsumTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? WAvgAgg(TInt[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TnumberWavgTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TnumberTavgFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + + public static Temporal? WCount(TInt[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalWcountTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + + public static Temporal? WMax(TInt[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TintWmaxTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + + public static Temporal? WMin(TInt[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TintWminTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + + public static Temporal? WSum(TInt[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TintWsumTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + } } diff --git a/MEOS.NET/Types/TJsonb.g.cs b/MEOS.NET/Types/TJsonb.g.cs index 046293a..74ce3bf 100644 --- a/MEOS.NET/Types/TJsonb.g.cs +++ b/MEOS.NET/Types/TJsonb.g.cs @@ -422,6 +422,37 @@ public bool Same(TJsonb temp2) public Jsonb?[] Values() => MEOSFactory.WrapJsonbArray(Meos.TjsonbValues(this.Ptr)); + public static Temporal? AppendInstantAgg(TJsonb[] values, string interp, double maxdist, Interval maxt) + { + IntPtr _maxt = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(maxt, _maxt, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTinstTransfn(_state, _v.Ptr, Meos.InterptypeFromString(interp), maxdist, _maxt); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_maxt); + } + } + + public static Temporal? AppendSequenceAgg(TJsonb[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTseqTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + public static Temporal? FromBaseTemp(Jsonb jsonb, Temporal temp) => MEOSFactory.WrapTemporal(Meos.TjsonbFromBaseTemp(jsonb.Ptr, temp.Ptr)); @@ -431,5 +462,47 @@ public bool Same(TJsonb temp2) public static Temporal? FromText(string str) => MEOSFactory.WrapTemporal(Meos.TjsonbIn(str)); + public static Temporal? MergeAgg(TJsonb[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalMergeTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TCount(TJsonb[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? WCount(TJsonb[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalWcountTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + } } diff --git a/MEOS.NET/Types/TNPoint.g.cs b/MEOS.NET/Types/TNPoint.g.cs index 509a15d..1139d0b 100644 --- a/MEOS.NET/Types/TNPoint.g.cs +++ b/MEOS.NET/Types/TNPoint.g.cs @@ -319,6 +319,37 @@ public bool SameRid(TNPoint temp2) public NPoint?[] Values() => MEOSFactory.WrapNPointArray(Meos.TnpointValues(this.Ptr)); + public static Temporal? AppendInstantAgg(TNPoint[] values, string interp, double maxdist, Interval maxt) + { + IntPtr _maxt = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(maxt, _maxt, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTinstTransfn(_state, _v.Ptr, Meos.InterptypeFromString(interp), maxdist, _maxt); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_maxt); + } + } + + public static Temporal? AppendSequenceAgg(TNPoint[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTseqTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + public static Temporal? FromBaseTemp(NPoint np, Temporal temp) => MEOSFactory.WrapTemporal(Meos.TnpointFromBaseTemp(np.Ptr, temp.Ptr)); @@ -337,5 +368,58 @@ public bool SameRid(TNPoint temp2) public static Temporal? FromText(string str) => MEOSFactory.WrapTemporal(Meos.TnpointIn(str)); + public static Temporal? MergeAgg(TNPoint[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalMergeTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TCentroid(TNPoint[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TnpointTcentroidTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TpointTcentroidFinalfn(_state)); + } + + public static Temporal? TCount(TNPoint[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? WCount(TNPoint[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalWcountTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + } } diff --git a/MEOS.NET/Types/TPCPatch.g.cs b/MEOS.NET/Types/TPCPatch.g.cs index 0fcf589..e1428c6 100644 --- a/MEOS.NET/Types/TPCPatch.g.cs +++ b/MEOS.NET/Types/TPCPatch.g.cs @@ -165,6 +165,37 @@ public uint StartNpoints() public PCPatch?[] Values() => MEOSFactory.WrapPCPatchArray(Meos.TpcpatchValues(this.Ptr)); + public static Temporal? AppendInstantAgg(TPCPatch[] values, string interp, double maxdist, Interval maxt) + { + IntPtr _maxt = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(maxt, _maxt, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTinstTransfn(_state, _v.Ptr, Meos.InterptypeFromString(interp), maxdist, _maxt); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_maxt); + } + } + + public static Temporal? AppendSequenceAgg(TPCPatch[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTseqTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + public static Temporal? FromBaseTemp(PCPatch pa, Temporal temp) => MEOSFactory.WrapTemporal(Meos.TpcpatchFromBaseTemp(pa.Ptr, temp.Ptr)); @@ -183,5 +214,69 @@ public uint StartNpoints() public static Temporal? FromText(string str) => MEOSFactory.WrapTemporal(Meos.TpcpatchIn(str)); + public static Temporal? MergeAgg(TPCPatch[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalMergeTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TCount(TPCPatch[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? Tdensity(TPCPatch[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TpcpatchTdensityTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? Tnpoints(TPCPatch[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TpcpatchTnpointsTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? WCount(TPCPatch[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalWcountTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + } } diff --git a/MEOS.NET/Types/TPCPoint.g.cs b/MEOS.NET/Types/TPCPoint.g.cs index 433a0b3..a6d4cd3 100644 --- a/MEOS.NET/Types/TPCPoint.g.cs +++ b/MEOS.NET/Types/TPCPoint.g.cs @@ -142,6 +142,37 @@ public uint Pcid() public PCPoint?[] Values() => MEOSFactory.WrapPCPointArray(Meos.TpcpointValues(this.Ptr)); + public static Temporal? AppendInstantAgg(TPCPoint[] values, string interp, double maxdist, Interval maxt) + { + IntPtr _maxt = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(maxt, _maxt, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTinstTransfn(_state, _v.Ptr, Meos.InterptypeFromString(interp), maxdist, _maxt); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_maxt); + } + } + + public static Temporal? AppendSequenceAgg(TPCPoint[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTseqTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + public static Temporal? FromBaseTemp(PCPoint pt, Temporal temp) => MEOSFactory.WrapTemporal(Meos.TpcpointFromBaseTemp(pt.Ptr, temp.Ptr)); @@ -160,5 +191,47 @@ public uint Pcid() public static Temporal? FromText(string str) => MEOSFactory.WrapTemporal(Meos.TpcpointIn(str)); + public static Temporal? MergeAgg(TPCPoint[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalMergeTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TCount(TPCPoint[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? WCount(TPCPoint[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalWcountTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + } } diff --git a/MEOS.NET/Types/TPose.g.cs b/MEOS.NET/Types/TPose.g.cs index 35bccb8..ba2d5f0 100644 --- a/MEOS.NET/Types/TPose.g.cs +++ b/MEOS.NET/Types/TPose.g.cs @@ -364,6 +364,37 @@ public bool Same(TPose temp2) public Temporal? Yaw() => MEOSFactory.WrapTemporal(Meos.TposeYaw(this.Ptr)); + public static Temporal? AppendInstantAgg(TPose[] values, string interp, double maxdist, Interval maxt) + { + IntPtr _maxt = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(maxt, _maxt, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTinstTransfn(_state, _v.Ptr, Meos.InterptypeFromString(interp), maxdist, _maxt); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_maxt); + } + } + + public static Temporal? AppendSequenceAgg(TPose[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTseqTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + public static Temporal? FromBaseTemp(Pose pose, Temporal temp) => MEOSFactory.WrapTemporal(Meos.TposeFromBaseTemp(pose.Ptr, temp.Ptr)); @@ -385,5 +416,47 @@ public bool Same(TPose temp2) public static Temporal? FromText(string str) => MEOSFactory.WrapTemporal(Meos.TposeIn(str)); + public static Temporal? MergeAgg(TPose[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalMergeTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TCount(TPose[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? WCount(TPose[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalWcountTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + } } diff --git a/MEOS.NET/Types/TPoseChain.g.cs b/MEOS.NET/Types/TPoseChain.g.cs index 49fa5b1..1fc45c1 100644 --- a/MEOS.NET/Types/TPoseChain.g.cs +++ b/MEOS.NET/Types/TPoseChain.g.cs @@ -301,6 +301,37 @@ public bool Same(TPoseChain temp2) public PoseChain?[] Values() => MEOSFactory.WrapPoseChainArray(Meos.TposechainValues(this.Ptr)); + public static Temporal? AppendInstantAgg(TPoseChain[] values, string interp, double maxdist, Interval maxt) + { + IntPtr _maxt = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(maxt, _maxt, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTinstTransfn(_state, _v.Ptr, Meos.InterptypeFromString(interp), maxdist, _maxt); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_maxt); + } + } + + public static Temporal? AppendSequenceAgg(TPoseChain[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTseqTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + public static Temporal? FromBaseTemp(PoseChain pc, Temporal temp) => MEOSFactory.WrapTemporal(Meos.TposechainFromBaseTemp(pc.Ptr, temp.Ptr)); @@ -322,5 +353,47 @@ public bool Same(TPoseChain temp2) public static Temporal? FromText(string str) => MEOSFactory.WrapTemporal(Meos.TposechainIn(str)); + public static Temporal? MergeAgg(TPoseChain[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalMergeTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TCount(TPoseChain[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? WCount(TPoseChain[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalWcountTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + } } diff --git a/MEOS.NET/Types/TQuadbin.g.cs b/MEOS.NET/Types/TQuadbin.g.cs index 6114f7d..3fe9328 100644 --- a/MEOS.NET/Types/TQuadbin.g.cs +++ b/MEOS.NET/Types/TQuadbin.g.cs @@ -217,6 +217,37 @@ public Quadbin Value() public Quadbin[] Values() => Array.ConvertAll(Meos.TquadbinValues(this.Ptr), v => new Quadbin(v)); + public static Temporal? AppendInstantAgg(TQuadbin[] values, string interp, double maxdist, Interval maxt) + { + IntPtr _maxt = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(maxt, _maxt, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTinstTransfn(_state, _v.Ptr, Meos.InterptypeFromString(interp), maxdist, _maxt); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_maxt); + } + } + + public static Temporal? AppendSequenceAgg(TQuadbin[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTseqTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + public static Temporal? FromBaseTemp(Quadbin value, Temporal temp) => MEOSFactory.WrapTemporal(Meos.TquadbinFromBaseTemp(value.value, temp.Ptr)); @@ -235,5 +266,47 @@ public Quadbin[] Values() public static Temporal? FromText(string str) => MEOSFactory.WrapTemporal(Meos.TquadbinIn(str)); + public static Temporal? MergeAgg(TQuadbin[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalMergeTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TCount(TQuadbin[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? WCount(TQuadbin[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalWcountTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + } } diff --git a/MEOS.NET/Types/TRGeometry.g.cs b/MEOS.NET/Types/TRGeometry.g.cs index 32c8bd4..f995783 100644 --- a/MEOS.NET/Types/TRGeometry.g.cs +++ b/MEOS.NET/Types/TRGeometry.g.cs @@ -440,6 +440,37 @@ public bool Same(TRGeometry temp2) public Temporal? Yaw() => MEOSFactory.WrapTemporal(Meos.TrgeometryYaw(this.Ptr)); + public static Temporal? AppendInstantAgg(TRGeometry[] values, string interp, double maxdist, Interval maxt) + { + IntPtr _maxt = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(maxt, _maxt, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTinstTransfn(_state, _v.Ptr, Meos.InterptypeFromString(interp), maxdist, _maxt); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_maxt); + } + } + + public static Temporal? AppendSequenceAgg(TRGeometry[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTseqTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + public static Temporal? FromEWKB(byte[] wkb) => Temporal.FromWKB(wkb); @@ -455,5 +486,47 @@ public bool Same(TRGeometry temp2) public static Temporal? FromText(string str) => MEOSFactory.WrapTemporal(Meos.TrgeometryIn(str)); + public static Temporal? MergeAgg(TRGeometry[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalMergeTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TCount(TRGeometry[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? WCount(TRGeometry[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalWcountTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + } } diff --git a/MEOS.NET/Types/TS2Cell.g.cs b/MEOS.NET/Types/TS2Cell.g.cs index 092e42d..1c54f9c 100644 --- a/MEOS.NET/Types/TS2Cell.g.cs +++ b/MEOS.NET/Types/TS2Cell.g.cs @@ -199,6 +199,37 @@ public S2Cell Value() public S2Cell[] Values() => Array.ConvertAll(Meos.Ts2cellValues(this.Ptr), v => new S2Cell(v)); + public static Temporal? AppendInstantAgg(TS2Cell[] values, string interp, double maxdist, Interval maxt) + { + IntPtr _maxt = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(maxt, _maxt, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTinstTransfn(_state, _v.Ptr, Meos.InterptypeFromString(interp), maxdist, _maxt); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_maxt); + } + } + + public static Temporal? AppendSequenceAgg(TS2Cell[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTseqTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + public static Temporal? FromBaseTemp(S2Cell value, Temporal temp) => MEOSFactory.WrapTemporal(Meos.Ts2cellFromBaseTemp(value.value, temp.Ptr)); @@ -217,5 +248,47 @@ public S2Cell[] Values() public static Temporal? FromText(string str) => MEOSFactory.WrapTemporal(Meos.Ts2cellIn(str)); + public static Temporal? MergeAgg(TS2Cell[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalMergeTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TCount(TS2Cell[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? WCount(TS2Cell[] values, Interval interv) + { + IntPtr _interv = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(interv, _interv, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalWcountTransfn(_state, _v.Ptr, _interv); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_interv); + } + } + } } diff --git a/MEOS.NET/Types/TText.g.cs b/MEOS.NET/Types/TText.g.cs index becb6c8..dec67a4 100644 --- a/MEOS.NET/Types/TText.g.cs +++ b/MEOS.NET/Types/TText.g.cs @@ -244,6 +244,37 @@ public bool Same(TText temp2) public Text?[] Values() => MEOSFactory.WrapTextArray(Meos.TtextValues(this.Ptr)); + public static Temporal? AppendInstantAgg(TText[] values, string interp, double maxdist, Interval maxt) + { + IntPtr _maxt = Marshal.AllocHGlobal(Marshal.SizeOf()); + try + { + Marshal.StructureToPtr(maxt, _maxt, false); + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTinstTransfn(_state, _v.Ptr, Meos.InterptypeFromString(interp), maxdist, _maxt); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + finally + { + Marshal.FreeHGlobal(_maxt); + } + } + + public static Temporal? AppendSequenceAgg(TText[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTseqTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + public static Temporal? FromBaseTemp(Text txt, Temporal temp) => MEOSFactory.WrapTemporal(Meos.TtextFromBaseTemp(txt.Ptr, temp.Ptr)); @@ -253,5 +284,49 @@ public bool Same(TText temp2) public static Temporal? FromText(string str) => MEOSFactory.WrapTemporal(Meos.TtextIn(str)); + public static Temporal? MergeAgg(TText[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalMergeTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TCount(TText[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TMaxAgg(TText[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TtextTmaxTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TMinAgg(TText[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TtextTminTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + } } diff --git a/MEOS.NET/Types/Temporal.g.cs b/MEOS.NET/Types/Temporal.g.cs index 7787805..cd4ec8b 100644 --- a/MEOS.NET/Types/Temporal.g.cs +++ b/MEOS.NET/Types/Temporal.g.cs @@ -587,17 +587,6 @@ public bool UpperInc() public Set? Valueset() => MEOSFactory.WrapSet(Meos.TemporalValueset(this.Ptr)); - public static Temporal? AppendSequenceAgg(Temporal[] values) - { - IntPtr _state = IntPtr.Zero; - foreach (var _v in values) - { - _state = Meos.TemporalAppTseqTransfn(_state, _v.Ptr); - } - - return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); - } - public static Temporal? FromHexWKB(string hexwkb) => MEOSFactory.WrapTemporal(Meos.TemporalFromHexwkb(hexwkb)); @@ -614,17 +603,6 @@ public bool UpperInc() } } - public static Temporal? MergeAgg(Temporal[] values) - { - IntPtr _state = IntPtr.Zero; - foreach (var _v in values) - { - _state = Meos.TemporalMergeTransfn(_state, _v.Ptr); - } - - return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); - } - public static Temporal? MergeArray(Temporal[] temparr) { IntPtr[] _temparrValues = new IntPtr[temparr.Length]; @@ -644,82 +622,5 @@ public bool UpperInc() } } - public static Temporal? ReachabilityFilterAgg(Temporal[] values, double maxspeed) - { - IntPtr _state = IntPtr.Zero; - foreach (var _v in values) - { - _state = Meos.TemporalReachabilityFilterTransfn(_state, _v.Ptr, maxspeed); - } - - return MEOSFactory.WrapTemporal(Meos.TemporalReachabilityFilterFinalfn(_state)); - } - - public static Temporal? TAndAgg(Temporal[] values) - { - IntPtr _state = IntPtr.Zero; - foreach (var _v in values) - { - _state = Meos.TboolTandTransfn(_state, _v.Ptr); - } - - return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); - } - - public static Temporal? TAvg(Temporal[] values) - { - IntPtr _state = IntPtr.Zero; - foreach (var _v in values) - { - _state = Meos.TnumberTavgTransfn(_state, _v.Ptr); - } - - return MEOSFactory.WrapTemporal(Meos.TnumberTavgFinalfn(_state)); - } - - public static Temporal? TCount(Temporal[] values) - { - IntPtr _state = IntPtr.Zero; - foreach (var _v in values) - { - _state = Meos.TemporalTcountTransfn(_state, _v.Ptr); - } - - return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); - } - - public static Temporal? TOrAgg(Temporal[] values) - { - IntPtr _state = IntPtr.Zero; - foreach (var _v in values) - { - _state = Meos.TboolTorTransfn(_state, _v.Ptr); - } - - return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); - } - - public static Temporal? Tdensity(Temporal[] values) - { - IntPtr _state = IntPtr.Zero; - foreach (var _v in values) - { - _state = Meos.TpcpatchTdensityTransfn(_state, _v.Ptr); - } - - return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); - } - - public static Temporal? Tnpoints(Temporal[] values) - { - IntPtr _state = IntPtr.Zero; - foreach (var _v in values) - { - _state = Meos.TpcpatchTnpointsTransfn(_state, _v.Ptr); - } - - return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); - } - } } diff --git a/tools/objectgen.py b/tools/objectgen.py index 5ec60e0..89920ab 100644 --- a/tools/objectgen.py +++ b/tools/objectgen.py @@ -1364,14 +1364,27 @@ def inherited_names(self, cls: str) -> set[tuple]: p = self.m.parent.get(p) return names + def aggregate_class(self, agg: dict, value_ctype: str) -> str | None: + """The class of an aggregate, as #aggregateClass of MEOS.js's + codegen/ObjectGenerator.ts reads it: the leaf of the lattice whose prefix + is the SQL type of its values (`tint` names TInt), as the object model + reads a function's class off its prefix, else the class of the C type its + transition takes them as.""" + sql = (agg.get("args") or [None])[0] + for name, node in self.m.om["lattice"].items(): + if node.get("kind") == "leaf" and sql in (node.get("prefixes") or []): + return name + return self.m.class_for_ctype(clean(value_ctype)) + def aggregate_methods(self, cls: str) -> list[Method]: """The aggregates over the values of a class, one static method each. Built beside #method_for, whose #map_param and #map_return it calls for the transition's arguments and the final function's result, as #aggregateMethods of MEOS.js's codegen/ObjectGenerator.ts builds them: - the catalog's `aggregates` whose transition takes the class's C type - after its state, named as an engine holding one function per name calls + the catalog's `aggregates` #aggregate_class gives the class, so each + transition of tMinAgg is a method of its own class (TInt.TMinAgg, + TFloat.TMinAgg), named as an engine holding one function per name calls them, the aggregate's `altSqlName` or else its `sqlName`, as MobilityDuck registers one. The method threads the transition over the values from a NULL state, as MEOS's C callers do, and answers the final function's @@ -1385,7 +1398,7 @@ def aggregate_methods(self, cls: str) -> list[Method]: f = transition and self.m.functions.get(transition) if not f or not final or len(f.get("params", [])) < 2: continue - if self.m.class_for_ctype(clean(f["params"][1]["canonical"])) != cls: + if self.aggregate_class(agg, f["params"][1]["canonical"]) != cls: continue name = agg.get("altSqlName") or agg["sqlName"] seen = by_name.setdefault(name, []) @@ -1412,13 +1425,20 @@ def aggregate_methods(self, cls: str) -> list[Method]: (codegen.csharp_param_name(p["name"]) if p["name"] else "arg"): p for p in f.get("params", []) } - mapped = [] + mapped, structs = [], [] for i, (cs_type, pname) in enumerate(tsig[1][1:]): p = c_by_name.get(pname, {}) arg = "_v" if i == 0 else ident(pname) m = self.map_param(p.get("canonical", cs_type), cs_type, arg, self.m.class_for_value(p) if p else None) - if m is None or m[1] == scratch(arg): + if m is not None and m[1] == scratch(arg): + # A struct argument passed by value is laid out once for + # every call, as #call_body lays one out for its call. + if i == 0: + m = None + else: + structs.append((arg, m[0])) + if m is None: mapped = None break mapped.append((m, pname)) @@ -1428,14 +1448,16 @@ def aggregate_methods(self, cls: str) -> list[Method]: f"{transition} / {final}") continue (item_type, item_arg), _ = mapped[0] + # A value of an ancestor's C type is taken as this class's own. + if item_type in self.m.ancestors(cls): + item_type = cls params = [(f"{item_type}[]", "values")] + [ (t, pname) for (t, _a), pname in mapped[1:]] args = ", ".join(["_state", item_arg] + [a for (_t, a), _p in mapped[1:]]) call = f"Meos.{codegen.public_name(transition)}({args})" answer = ret[1].replace("$", f"Meos.{codegen.public_name(final)}(_state)") method = Method(pascal(name), ret[0], params, answer, True) - method.lines = [ - " {", + loop = [ " IntPtr _state = IntPtr.Zero;", " foreach (var _v in values)", " {", @@ -1443,8 +1465,18 @@ def aggregate_methods(self, cls: str) -> list[Method]: " }", "", f" return {answer};", - " }", ] + if structs: + setup = [f" IntPtr {scratch(n)} = " + f"Marshal.AllocHGlobal(Marshal.SizeOf<{t}>());" for n, t in structs] + fill = [f" Marshal.StructureToPtr({n}, {scratch(n)}, false);" + for n, _t in structs] + free = [f" Marshal.FreeHGlobal({scratch(n)});" for n, _t in structs] + loop = (setup + [" try", " {"] + fill + + [f" {line}" if line else "" for line in loop] + + [" }", " finally", " {"] + free + + [" }"]) + method.lines = [" {"] + loop + [" }"] methods.append(method) return methods